@vue-skuilder/db 0.1.11-7 → 0.1.11

package/src/core/interfaces/courseDB.ts

@@ -1,6 +1,6 @@
 import { CourseConfig, CourseElo, DataShape, SkuilderCourseData } from '@vue-skuilder/common';
 import { StudySessionNewItem, StudySessionItem } from './contentSource';
-import { TagStub, Tag } from '../types/types-legacy';
+import { TagStub, Tag, QualifiedCardID } from '../types/types-legacy';
 import { DataLayerResult } from '../types/db';
 import { NavigationStrategyManager } from './navigationStrategyManager';
 
@@ -53,7 +53,16 @@ export interface CourseDBInterface extends NavigationStrategyManager {
   /**
    * Get cards sorted by ELO rating
    */
-  getCardsByELO(elo: number, limit?: number): Promise<string[]>;
+  getCardsByELO(
+    elo: number,
+    limit?: number
+  ): Promise<
+    {
+      courseID: string;
+      cardID: string;
+      elo?: number;
+    }[]
+  >;
 
   /**
    * Get ELO data for specific cards
@@ -75,7 +84,7 @@ export interface CourseDBInterface extends NavigationStrategyManager {
    */
   getCardsCenteredAtELO(
     options: { limit: number; elo: 'user' | 'random' | number },
-    filter?: (id: string) => boolean
+    filter?: (card: QualifiedCardID) => boolean
   ): Promise<StudySessionItem[]>;
 
   /**
@@ -136,4 +145,18 @@ export interface CourseDBInterface extends NavigationStrategyManager {
       elo: CourseElo;
     }[]
   >;
+
+  /**
+   * Search for cards by text content
+   * @param query Text to search for
+   * @returns Array of matching card data
+   */
+  searchCards(query: string): Promise<any[]>;
+
+  /**
+   * Find documents using PouchDB query syntax
+   * @param request PouchDB find request
+   * @returns Query response
+   */
+  find(request: PouchDB.Find.FindRequest<any>): Promise<PouchDB.Find.FindResponse<any>>;
 }

package/src/core/interfaces/dataLayerProvider.ts

@@ -1,6 +1,6 @@
 // db/src/core/interfaces.ts
 
-import { UserDBInterface } from './userDB';
+import { UserDBInterface, UserDBReader } from './userDB';
 import { CourseDBInterface, CoursesDBInterface } from './courseDB';
 import { ClassroomDBInterface } from './classroomDB';
 import { AdminDBInterface } from './adminDB';
@@ -14,6 +14,14 @@ export interface DataLayerProvider {
    */
   getUserDB(): UserDBInterface;
 
+  /**
+   * Create a UserDBReader for a specific user (admin access required)
+   * Uses session authentication to verify requesting user is admin
+   * @param targetUsername - The username to create a reader for
+   * @throws Error if requesting user is not 'admin'
+   */
+  createUserReaderForUser(targetUsername: string): Promise<UserDBReader>;
+
   /**
    * Get a course database interface
    */

package/src/core/interfaces/userDB.ts

@@ -6,46 +6,16 @@ import {
 } from '@db/core/types/user';
 import { CourseElo, Status } from '@vue-skuilder/common';
 import { Moment } from 'moment';
-import { CardHistory, CardRecord } from '../types/types-legacy';
+import { CardHistory, CardRecord, QualifiedCardID } from '../types/types-legacy';
 import { UserConfig } from '../types/user';
 import { DocumentUpdater } from '@db/study';
 
 /**
- * User data and authentication
+ * Read-only user data operations
  */
-export interface UserDBInterface extends DocumentUpdater {
-  /**
-   * Create a new user account
-   */
-  createAccount(
-    username: string,
-    password: string
-  ): Promise<{
-    status: Status;
-    error: string;
-  }>;
-
-  /**
-   * Log in as a user
-   */
-  login(
-    username: string,
-    password: string
-  ): Promise<{
-    ok: boolean;
-    name?: string;
-    roles?: string[];
-  }>;
-
-  /**
-   * Log out the current user
-   */
-  logout(): Promise<{
-    ok: boolean;
-  }>;
-
+export interface UserDBReader {
+  get<T>(id: string): Promise<T & PouchDB.Core.RevisionIdMeta>;
   getUsername(): string;
-
   isLoggedIn(): boolean;
 
   /**
@@ -53,16 +23,6 @@ export interface UserDBInterface extends DocumentUpdater {
    */
   getConfig(): Promise<UserConfig>;
 
-  /**
-   * Update user configuration
-   */
-  setConfig(config: Partial<UserConfig>): Promise<void>;
-
-  /**
-   * Record a user's interaction with a card
-   */
-  putCardRecord<T extends CardRecord>(record: T): Promise<CardHistory<CardRecord>>;
-
   /**
    * Get cards that the user has seen
    */
@@ -71,17 +31,7 @@ export interface UserDBInterface extends DocumentUpdater {
   /**
    * Get cards that are actively scheduled for review
    */
-  getActiveCards(): Promise<string[]>;
-
-  /**
-   * Register user for a course
-   */
-  registerForCourse(courseId: string, previewMode?: boolean): Promise<PouchDB.Core.Response>;
-
-  /**
-   * Drop a course registration
-   */
-  dropCourse(courseId: string, dropStatus?: string): Promise<PouchDB.Core.Response>;
+  getActiveCards(): Promise<QualifiedCardID[]>;
 
   /**
    * Get user's course registrations
@@ -106,6 +56,43 @@ export interface UserDBInterface extends DocumentUpdater {
 
   getActivityRecords(): Promise<ActivityRecord[]>;
 
+  /**
+   * Get user's classroom registrations
+   */
+  getUserClassrooms(): Promise<ClassroomRegistrationDoc>;
+
+  /**
+   * Get user's active classes
+   */
+  getActiveClasses(): Promise<string[]>;
+
+  getCourseInterface(courseId: string): Promise<UsrCrsDataInterface>;
+}
+
+/**
+ * User data mutation operations
+ */
+export interface UserDBWriter extends DocumentUpdater {
+  /**
+   * Update user configuration
+   */
+  setConfig(config: Partial<UserConfig>): Promise<void>;
+
+  /**
+   * Record a user's interaction with a card
+   */
+  putCardRecord<T extends CardRecord>(record: T): Promise<CardHistory<CardRecord>>;
+
+  /**
+   * Register user for a course
+   */
+  registerForCourse(courseId: string, previewMode?: boolean): Promise<PouchDB.Core.Response>;
+
+  /**
+   * Drop a course registration
+   */
+  dropCourse(courseId: string, dropStatus?: string): Promise<PouchDB.Core.Response>;
+
   /**
    * Schedule a card for review
    */
@@ -137,28 +124,57 @@ export interface UserDBInterface extends DocumentUpdater {
   dropFromClassroom(classId: string): Promise<PouchDB.Core.Response>;
 
   /**
-   * Get user's classroom registrations
+   * Update user's ELO rating for a course
    */
-  getUserClassrooms(): Promise<ClassroomRegistrationDoc>;
+  updateUserElo(courseId: string, elo: CourseElo): Promise<PouchDB.Core.Response>;
 
   /**
-   * Get user's active classes
+   * Reset all user data (progress, registrations, etc.) while preserving authentication
    */
-  getActiveClasses(): Promise<string[]>;
+  resetUserData(): Promise<{ status: Status; error?: string }>;
+}
 
+/**
+ * Authentication and account management operations
+ */
+export interface UserDBAuthenticator {
   /**
-   * Update user's ELO rating for a course
+   * Create a new user account
    */
-  updateUserElo(courseId: string, elo: CourseElo): Promise<PouchDB.Core.Response>;
+  createAccount(
+    username: string,
+    password: string
+  ): Promise<{
+    status: Status;
+    error: string;
+  }>;
 
   /**
-   * Reset all user data (progress, registrations, etc.) while preserving authentication
+   * Log in as a user
    */
-  resetUserData(): Promise<{ status: Status; error?: string }>;
+  login(
+    username: string,
+    password: string
+  ): Promise<{
+    ok: boolean;
+    name?: string;
+    roles?: string[];
+  }>;
 
-  getCourseInterface(courseId: string): Promise<UsrCrsDataInterface>;
+  /**
+   * Log out the current user
+   */
+  logout(): Promise<{
+    ok: boolean;
+  }>;
 }
 
+/**
+ * Complete user database interface - combines all user operations
+ * This maintains backward compatibility with existing code
+ */
+export interface UserDBInterface extends UserDBReader, UserDBWriter, UserDBAuthenticator {}
+
 export interface UserCourseSettings {
   [setting: string]: string | number | boolean;
 }

package/src/core/navigators/elo.ts

@@ -3,7 +3,7 @@ import { CourseDBInterface } from '../interfaces/courseDB';
 import { UserDBInterface } from '../interfaces/userDB';
 import { ContentNavigator } from './index';
 import { CourseElo } from '@vue-skuilder/common';
-import { StudySessionReviewItem, StudySessionNewItem } from '..';
+import { StudySessionReviewItem, StudySessionNewItem, QualifiedCardID } from '..';
 
 export default class ELONavigator extends ContentNavigator {
   user: UserDBInterface;
@@ -59,13 +59,16 @@ export default class ELONavigator extends ContentNavigator {
   async getNewCards(limit: number = 99): Promise<StudySessionNewItem[]> {
     const activeCards = await this.user.getActiveCards();
     return (
-      await this.course.getCardsCenteredAtELO({ limit: limit, elo: 'user' }, (c: string) => {
-        if (activeCards.some((ac) => c.includes(ac))) {
-          return false;
-        } else {
-          return true;
+      await this.course.getCardsCenteredAtELO(
+        { limit: limit, elo: 'user' },
+        (c: QualifiedCardID) => {
+          if (activeCards.some((ac) => c.cardID === ac.cardID)) {
+            return false;
+          } else {
+            return true;
+          }
         }
-      })
+      )
     ).map((c) => {
       return {
         ...c,

package/src/core/navigators/index.ts

@@ -32,7 +32,7 @@ export abstract class ContentNavigator implements StudyContentSource {
     let NavigatorImpl;
 
     // Try different extension variations
-    const variations = ['', '.js', '.ts'];
+    const variations = ['.ts', '.js', ''];
 
     for (const ext of variations) {
       try {

package/src/core/types/types-legacy.ts

@@ -21,6 +21,11 @@ export enum DocType {
   NAVIGATION_STRATEGY = 'NAVIGATION_STRATEGY',
 }
 
+export interface QualifiedCardID {
+  courseID: string;
+  cardID: string;
+}
+
 /**
  * Interface for all data on course content and pedagogy stored
  * in the c/pouch database.

package/src/impl/common/BaseUserDB.ts

@@ -217,6 +217,10 @@ Currently logged-in as ${this._username}.`
     return ret;
   }
 
+  public async get<T>(id: string): Promise<T & PouchDB.Core.RevisionIdMeta> {
+    return this.localDB.get<T>(id);
+  }
+
   public update<T extends PouchDB.Core.Document<object>>(id: string, update: Update<T>) {
     return this.updateQueue.update(id, update);
   }
@@ -273,7 +277,12 @@ Currently logged-in as ${this._username}.`
       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,
+      };
+    });
   }
 
   public async getActivityRecords(): Promise<ActivityRecord[]> {
@@ -620,8 +629,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) => {
+      log(`Error in applyDesignDocs background task: ${error}`);
+      if (error && typeof error === 'object') {
+        log(`Full error details in applyDesignDocs: ${JSON.stringify(error)}`);
+      }
+    });
+    this.deduplicateReviews().catch((error) => {
+      log(`Error in deduplicateReviews background task: ${error}`);
+      if (error && typeof error === 'object') {
+        log(`Full error details in background task: ${JSON.stringify(error)}`);
+      }
+    });
     BaseUser._initialized = true;
   }
 
@@ -641,12 +660,18 @@ Currently logged-in as ${this._username}.`
   ];
 
   private async applyDesignDocs() {
+    log(`Starting applyDesignDocs for user: ${this._username}`);
+    log(`Remote DB name: ${this.remoteDB.name || 'unknown'}`);
+
     if (this._username === 'admin') {
       // Skip admin user
+      log('Skipping design docs for admin user');
       return;
     }
 
+    log(`Applying ${BaseUser.designDocs.length} design docs`);
     for (const doc of BaseUser.designDocs) {
+      log(`Applying design doc: ${doc._id}`);
       try {
         // Try to get existing doc
         try {
@@ -759,6 +784,8 @@ Currently logged-in as ${this._username}.`
   private async deduplicateReviews() {
     try {
       log('Starting deduplication of scheduled reviews...');
+      log(`Remote DB name: ${this.remoteDB.name || 'unknown'}`);
+      log(`Write DB name: ${this.writeDB.name || 'unknown'}`);
       /**
        * Maps the qualified-id of a scheduled review card to
        * the docId of the same scheduled review.
@@ -770,6 +797,9 @@ Currently logged-in as ${this._username}.`
       const reviewsMap: { [index: string]: string } = {};
       const duplicateDocIds: string[] = [];
 
+      log(
+        `Attempting to query remoteDB for reviewCards/reviewCards. Database: ${this.remoteDB.name || 'unknown'}`
+      );
       const scheduledReviews = await this.remoteDB.query<{
         id: string;
         value: string;
@@ -817,6 +847,18 @@ Currently logged-in as ${this._username}.`
       }
     } catch (error) {
       log(`Error during review deduplication: ${error}`);
+      if (error && typeof error === 'object' && 'status' in error && error.status === 404) {
+        log(
+          `Database not found (404) during review deduplication. Database: ${this.remoteDB.name || 'unknown'}`
+        );
+        log(
+          `This might indicate the user database doesn't exist or the reviewCards view isn't available`
+        );
+      }
+      // Log full error details for debugging
+      if (error && typeof error === 'object') {
+        log(`Full error details: ${JSON.stringify(error)}`);
+      }
     }
   }
 

package/src/impl/couch/CouchDBSyncStrategy.ts

@@ -8,7 +8,7 @@ import type { SyncStrategy } from '../common/SyncStrategy';
 import type { AccountCreationResult, AuthenticationResult } from '../common/types';
 import { getLocalUserDB, hexEncode, updateGuestAccountExpirationDate } from '../common';
 import pouch from './pouchdb-setup';
-import { pouchDBincludeCredentialsConfig } from './index';
+import { createPouchDBConfig } from './index';
 import { getLoggedInUsername } from './auth';
 
 const log = (s: any) => {
@@ -207,7 +207,7 @@ export class CouchDBSyncStrategy implements SyncStrategy {
     // 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) {

package/src/impl/couch/PouchDataLayerProvider.ts

@@ -7,6 +7,7 @@ import {
   CourseDBInterface,
   DataLayerProvider,
   UserDBInterface,
+  UserDBReader,
 } from '../../core/interfaces';
 import { logger } from '../../util/logger';
 import { initializeDataDirectory } from '../../util/dataDirectory';
@@ -107,6 +108,26 @@ export class CouchDataLayerProvider implements DataLayerProvider {
     return new AdminDB();
   }
 
+  async createUserReaderForUser(targetUsername: string): Promise<UserDBReader> {
+    // Security check: only admin can access other users' data
+    const requestingUsername = await getLoggedInUsername();
+    if (requestingUsername !== 'admin') {
+      throw new Error('Unauthorized: Only admin users can access other users\' data');
+    }
+
+    logger.info(`Admin user '${requestingUsername}' requesting UserDBReader for '${targetUsername}'`);
+
+    // Create a new sync strategy for the target user
+    const syncStrategy = new CouchDBSyncStrategy();
+    
+    // Create a BaseUser instance for the target user
+    // Note: This creates a read-capable user instance without affecting the current session
+    const targetUserDB = await BaseUser.instance(syncStrategy, targetUsername);
+    
+    // Return as UserDBReader (which BaseUser implements since UserDBInterface extends UserDBReader)
+    return targetUserDB as UserDBReader;
+  }
+
   isReadOnly(): boolean {
     return false;
   }

package/src/impl/couch/adminDB.ts

@@ -1,7 +1,7 @@
 import pouch from './pouchdb-setup';
 import { ENV } from '@db/factory';
 import {
-  pouchDBincludeCredentialsConfig,
+  createPouchDBConfig,
   getStartAndEndKeys,
   getCredentialledCourseConfig,
   updateCredentialledCourseConfig,
@@ -21,7 +21,7 @@ export class AdminDB implements AdminDBInterface {
     //     if the user is not an admin
     this.usersDB = new pouch(
       ENV.COUCHDB_SERVER_PROTOCOL + '://' + ENV.COUCHDB_SERVER_URL + '_users',
-      pouchDBincludeCredentialsConfig
+      createPouchDBConfig()
     );
   }
 

package/src/impl/couch/auth.ts

@@ -39,10 +39,14 @@ export async function getCurrentSession(): Promise<SessionResponse> {
   try {
     // Handle case where ENV variables might not be properly set
     if (ENV.COUCHDB_SERVER_URL === NOT_SET || ENV.COUCHDB_SERVER_PROTOCOL === NOT_SET) {
-      throw new Error('CouchDB server configuration not properly initialized');
+      throw new Error(`CouchDB server configuration not properly initialized. Protocol: "${ENV.COUCHDB_SERVER_PROTOCOL}", URL: "${ENV.COUCHDB_SERVER_URL}"`);
     }
     
-    const url = `${ENV.COUCHDB_SERVER_PROTOCOL}://${ENV.COUCHDB_SERVER_URL}_session`;
+    // Ensure URL has proper slash before _session endpoint
+    const baseUrl = ENV.COUCHDB_SERVER_URL.endsWith('/') 
+      ? ENV.COUCHDB_SERVER_URL.slice(0, -1) 
+      : ENV.COUCHDB_SERVER_URL;
+    const url = `${ENV.COUCHDB_SERVER_PROTOCOL}://${baseUrl}/_session`;
     logger.debug(`Attempting session check at: ${url}`);
     
     const response = await fetch(url, {
@@ -57,8 +61,13 @@ export async function getCurrentSession(): Promise<SessionResponse> {
     const resp: SessionResponse = await response.json();
     return resp;
   } catch (error) {
-    logger.error(`Session check error: ${error}`);
-    throw new Error(`Session check failed: ${error}`);
+    // Use same URL construction logic for error reporting
+    const baseUrl = ENV.COUCHDB_SERVER_URL.endsWith('/') 
+      ? ENV.COUCHDB_SERVER_URL.slice(0, -1) 
+      : ENV.COUCHDB_SERVER_URL;
+    const url = `${ENV.COUCHDB_SERVER_PROTOCOL}://${baseUrl}/_session`;
+    logger.error(`Session check error attempting to connect to: ${url} - ${error}`);
+    throw new Error(`Session check failed connecting to ${url}: ${error}`);
   }
 }
 

package/src/impl/couch/classroomDB.ts

@@ -8,12 +8,7 @@ import { ENV } from '@db/factory';
 import { logger } from '@db/util/logger';
 import moment from 'moment';
 import pouch from './pouchdb-setup';
-import {
-  getCourseDB,
-  getStartAndEndKeys,
-  pouchDBincludeCredentialsConfig,
-  REVIEW_TIME_FORMAT,
-} from '.';
+import { getCourseDB, getStartAndEndKeys, createPouchDBConfig, REVIEW_TIME_FORMAT } from '.';
 import { CourseDB, getTag } from './courseDB';
 
 import { UserDBInterface } from '@db/core';
@@ -97,7 +92,7 @@ export class StudentClassroomDB
     const dbName = `classdb-student-${this._id}`;
     this._db = new pouch(
       ENV.COUCHDB_SERVER_PROTOCOL + '://' + ENV.COUCHDB_SERVER_URL + dbName,
-      pouchDBincludeCredentialsConfig
+      createPouchDBConfig()
     );
     try {
       const cfg = await this._db.get<ClassroomConfig>(CLASSROOM_CONFIG);
@@ -181,10 +176,13 @@ export class StudentClassroomDB
       }
     }
 
-    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)) {
+        // [ ] almost certainly broken after removing qualifiedID from StudySessionItem
         return false;
       } else {
         return true;
@@ -209,11 +207,11 @@ export class TeacherClassroomDB extends ClassroomDBBase implements TeacherClassr
     const stuDbName = `classdb-student-${this._id}`;
     this._db = new pouch(
       ENV.COUCHDB_SERVER_PROTOCOL + '://' + ENV.COUCHDB_SERVER_URL + dbName,
-      pouchDBincludeCredentialsConfig
+      createPouchDBConfig()
     );
     this._stuDb = new pouch(
       ENV.COUCHDB_SERVER_PROTOCOL + '://' + ENV.COUCHDB_SERVER_URL + stuDbName,
-      pouchDBincludeCredentialsConfig
+      createPouchDBConfig()
     );
     try {
       return this._db
@@ -297,7 +295,7 @@ export function getClassroomDB(classID: string, version: 'student' | 'teacher'):
 
   return new pouch(
     ENV.COUCHDB_SERVER_PROTOCOL + '://' + ENV.COUCHDB_SERVER_URL + dbName,
-    pouchDBincludeCredentialsConfig
+    createPouchDBConfig()
   );
 }
 

package/src/impl/couch/courseAPI.ts

@@ -1,5 +1,5 @@
 import pouch from './pouchdb-setup';
-import { pouchDBincludeCredentialsConfig } from '.';
+import { createPouchDBConfig } from '.';
 import { ENV } from '@db/factory';
 // import { DataShape } from '../..base-course/Interfaces/DataShape';
 import { NameSpacer, ShapeDescriptor } from '@vue-skuilder/common';
@@ -279,6 +279,6 @@ export function getCourseDB(courseID: string): PouchDB.Database {
   const dbName = `coursedb-${courseID}`;
   return new pouch(
     ENV.COUCHDB_SERVER_PROTOCOL + '://' + ENV.COUCHDB_SERVER_URL + dbName,
-    pouchDBincludeCredentialsConfig
+    createPouchDBConfig()
   );
 }