refactors: more migration away from qualifiedIDstr

... and into a defined interface { cardID, courseID : string }

Author: NiloCK

packages/db/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';
 
@@ -84,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[]>;
 
   /**

packages/db/src/core/interfaces/userDB.ts

@@ -6,7 +6,7 @@ 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';
 
@@ -17,55 +17,55 @@ export interface UserDBReader {
   get<T>(id: string): Promise<T & PouchDB.Core.RevisionIdMeta>;
   getUsername(): string;
   isLoggedIn(): boolean;
-  
+
   /**
    * Get user configuration
    */
   getConfig(): Promise<UserConfig>;
-  
+
   /**
    * Get cards that the user has seen
    */
   getSeenCards(courseId?: string): Promise<string[]>;
-  
+
   /**
    * Get cards that are actively scheduled for review
    */
-  getActiveCards(): Promise<string[]>;
-  
+  getActiveCards(): Promise<QualifiedCardID[]>;
+
   /**
    * Get user's course registrations
    */
   getCourseRegistrationsDoc(): Promise<CourseRegistrationDoc>;
-  
+
   /**
    * Get the registration doc for a specific course.
    * @param courseId
    */
   getCourseRegDoc(courseId: string): Promise<CourseRegistration>;
-  
+
   /**
    * Get user's active courses
    */
   getActiveCourses(): Promise<CourseRegistration[]>;
-  
+
   /**
    * Get user's pending reviews
    */
   getPendingReviews(courseId?: string): Promise<ScheduledCard[]>;
-  
+
   getActivityRecords(): Promise<ActivityRecord[]>;
-  
+
   /**
    * Get user's classroom registrations
    */
   getUserClassrooms(): Promise<ClassroomRegistrationDoc>;
-  
+
   /**
    * Get user's active classes
    */
   getActiveClasses(): Promise<string[]>;
-  
+
   getCourseInterface(courseId: string): Promise<UsrCrsDataInterface>;
 }
 
@@ -77,22 +77,22 @@ 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
    */
@@ -104,30 +104,30 @@ export interface UserDBWriter extends DocumentUpdater {
     scheduledFor: 'course' | 'classroom';
     schedulingAgentId: string;
   }): Promise<void>;
-  
+
   /**
    * Remove a scheduled card review
    */
   removeScheduledCardReview(reviewId: string): Promise<void>;
-  
+
   /**
    * Register user for a classroom
    */
   registerForClassroom(
     classId: string,
     registerAs: 'student' | 'teacher' | 'aide' | 'admin'
   ): Promise<PouchDB.Core.Response>;
-  
+
   /**
    * Drop user from classroom
    */
   dropFromClassroom(classId: string): Promise<PouchDB.Core.Response>;
-  
+
   /**
    * Update user's ELO rating for a course
    */
   updateUserElo(courseId: string, elo: CourseElo): Promise<PouchDB.Core.Response>;
-  
+
   /**
    * Reset all user data (progress, registrations, etc.) while preserving authentication
    */
@@ -173,8 +173,7 @@ export interface UserDBAuthenticator {
  * Complete user database interface - combines all user operations
  * This maintains backward compatibility with existing code
  */
-export interface UserDBInterface extends UserDBReader, UserDBWriter, UserDBAuthenticator {
-}
+export interface UserDBInterface extends UserDBReader, UserDBWriter, UserDBAuthenticator {}
 
 export interface UserCourseSettings {
   [setting: string]: string | number | boolean;

packages/db/src/core/navigators/elo.ts

@@ -3,7 +3,8 @@ 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 '..';
+import { StudySessionItem } from '../interfaces/contentSource';
 
 export default class ELONavigator extends ContentNavigator {
   user: UserDBInterface;
@@ -59,13 +60,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,

packages/db/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.

packages/db/src/impl/common/BaseUserDB.ts

@@ -277,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[]> {
@@ -657,7 +662,7 @@ 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');

packages/db/src/impl/couch/classroomDB.ts

@@ -181,7 +181,7 @@ export class StudentClassroomDB
     );
 
     return ret.filter((c) => {
-      if (activeCards.some((ac) => c.cardID.includes(ac))) {
+      if (activeCards.some((ac) => c.cardID === ac.cardID)) {
         // [ ] almost certainly broken after removing qualifiedID from StudySessionItem
         return false;
       } else {

packages/db/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';
@@ -547,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;
 
@@ -571,7 +578,7 @@ above:\n${above.rows.map((r) => `\t${r.id}-${r.key}\n`)}`;
       targetElo = options.elo;
     }
 
-    let cards: { courseID: string; cardID: string; elo?: number }[] = [];
+    let cards: (QualifiedCardID & { elo?: number })[] = [];
     let mult: number = 4;
     let previousCount: number = -1;
     let newCount: number = 0;
@@ -584,20 +591,8 @@ above:\n${above.rows.map((r) => `\t${r.id}-${r.key}\n`)}`;
       logger.debug(`Found ${cards.length} elo neighbor cards...`);
 
       if (filter) {
-        const filtered = cards
-          .map((card) => {
-            if (card.elo) {
-              return `${card.courseID}-${card.cardID}-${card.elo}`;
-            } else {
-              return `${card.courseID}-${card.cardID}`;
-            }
-          })
-          .filter(filter);
+        cards = cards.filter(filter);
         logger.debug(`Filtered to ${cards.length} cards...`);
-        cards = filtered.map((card) => {
-          const [courseID, cardID, elo] = card.split('-');
-          return { courseID, cardID, elo: elo ? parseInt(elo) : undefined };
-        });
       }
 
       mult *= 2;

packages/db/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';
@@ -141,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;
 
@@ -160,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,