@vue-skuilder/db 0.1.11-9 → 0.1.12

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.11-9",
+  "version": "0.1.12",
   "description": "Database layer for vue-skuilder",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@nilock2/pouchdb-authentication": "^1.0.2",
-    "@vue-skuilder/common": "0.1.11-9",
+    "@vue-skuilder/common": "0.1.12",
     "cross-fetch": "^4.1.0",
     "moment": "^2.29.4",
     "pouchdb": "^9.0.0",
@@ -57,5 +57,5 @@
     "tsup": "^8.0.2",
     "typescript": "~5.7.2"
   },
-  "stableVersion": "0.1.10"
+  "stableVersion": "0.1.12"
 }

package/src/core/interfaces/contentSource.ts

@@ -31,11 +31,12 @@ export function isReview(item: StudySessionItem): item is StudySessionReviewItem
 
 export interface StudySessionItem {
   status: 'new' | 'review' | 'failed-new' | 'failed-review';
-  qualifiedID: `${string}-${string}` | `${string}-${string}-${number}`;
-  cardID: string;
   contentSourceType: 'course' | 'classroom';
   contentSourceID: string;
+  // qualifiedID: `${string}-${string}` | `${string}-${string}-${number}`;
+  cardID: string;
   courseID: string;
+  elo?: number;
   // reviewID?: string;
 }
 

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/hardcodedOrder.ts

@@ -0,0 +1,64 @@
+import { CourseDBInterface, QualifiedCardID, StudySessionNewItem, StudySessionReviewItem, UserDBInterface } from '..';
+import { ContentNavigationStrategyData } from '../types/contentNavigationStrategy';
+import { ScheduledCard } from '../types/user';
+import { ContentNavigator } from './index';
+import { logger } from '../../util/logger';
+
+export default class HardcodedOrderNavigator extends ContentNavigator {
+  private orderedCardIds: string[] = [];
+  private user: UserDBInterface;
+  private course: CourseDBInterface;
+
+  constructor(
+    user: UserDBInterface,
+    course: CourseDBInterface,
+    strategyData: ContentNavigationStrategyData
+  ) {
+    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(): Promise<(StudySessionReviewItem & ScheduledCard)[]> {
+    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: number = 99): Promise<StudySessionNewItem[]> {
+    const activeCardIds = (await this.user.getActiveCards()).map((c: QualifiedCardID) => 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',
+      };
+    });
+  }
+}

package/src/core/navigators/index.ts

@@ -11,6 +11,7 @@ import { logger } from '../../util/logger';
 
 export enum Navigators {
   ELO = 'elo',
+  HARDCODED = 'hardcodedOrder',
 }
 
 /**
@@ -32,7 +33,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/contentNavigationStrategy.ts

@@ -1,10 +1,11 @@
 import { DocType, SkuilderCourseData } from './types-legacy';
+import type { DocTypePrefixes } from './types-legacy';
 
 /**
  *
  */
 export interface ContentNavigationStrategyData extends SkuilderCourseData {
-  id: string;
+  _id: `${typeof DocTypePrefixes[DocType.NAVIGATION_STRATEGY]}-${string}`;
   docType: DocType.NAVIGATION_STRATEGY;
   name: string;
   description: string;

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.
@@ -86,7 +91,7 @@ export interface QuestionData extends SkuilderCourseData {
   dataShapeList: PouchDB.Core.DocumentId[];
 }
 
-export const DocTypePrefixes: Record<string, string> = {
+export const DocTypePrefixes = {
   [DocType.CARD]: 'c',
   [DocType.DISPLAYABLE_DATA]: 'dd',
   [DocType.TAG]: 'TAG',
@@ -98,7 +103,7 @@ export const DocTypePrefixes: Record<string, string> = {
   [DocType.VIEW]: 'VIEW',
   [DocType.PEDAGOGY]: 'PEDAGOGY',
   [DocType.NAVIGATION_STRATEGY]: 'NAVIGATION_STRATEGY',
-};
+} as const;
 
 export interface CardHistory<T extends CardRecord> {
   _id: PouchDB.Core.DocumentId;

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 {
@@ -736,17 +761,21 @@ Currently logged-in as ${this._username}.`
     } catch (e) {
       const reason = e as PouchError;
       if (reason.status === 404) {
-        const initCardHistory: CardHistory<T> = {
-          _id: cardHistoryID,
-          cardID: record.cardID,
-          courseID: record.courseID,
-          records: [record],
-          lapses: 0,
-          streak: 0,
-          bestInterval: 0,
-        };
-        const putResult = await this.writeDB.put<CardHistory<T>>(initCardHistory);
-        return { ...initCardHistory, _rev: putResult.rev };
+        try {
+          const initCardHistory: CardHistory<T> = {
+            _id: cardHistoryID,
+            cardID: record.cardID,
+            courseID: record.courseID,
+            records: [record],
+            lapses: 0,
+            streak: 0,
+            bestInterval: 0,
+          };
+          const putResult = await this.writeDB.put<CardHistory<T>>(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}
@@ -759,6 +788,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 +801,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 +851,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()
     );
   }