@vue-skuilder/db 0.1.11-9 → 0.1.12

package/src/impl/static/StaticDataLayerProvider.ts

@@ -1,3 +1,4 @@
+
 // packages/db/src/impl/static/StaticDataLayerProvider.ts
 
 import {
@@ -7,6 +8,7 @@ import {
   CourseDBInterface,
   DataLayerProvider,
   UserDBInterface,
+  UserDBReader,
 } from '../../core/interfaces';
 import { logger } from '../../util/logger';
 import { StaticCourseManifest } from '../../util/packer/types';
@@ -16,39 +18,78 @@ import { StaticCoursesDB } from './coursesDB';
 import { BaseUser } from '../common';
 import { NoOpSyncStrategy } from './NoOpSyncStrategy';
 
+
+interface SkuilderManifest {
+  name?: string;
+  version?: string;
+  description?: string;
+  dependencies?: Record<string, string>;
+}
+
 interface StaticDataLayerConfig {
-  staticContentPath: string;
   localStoragePrefix?: string;
-  manifests: Record<string, StaticCourseManifest>; // courseId -> manifest
+  rootManifest: SkuilderManifest; // The parsed root skuilder.json object
+  rootManifestUrl: string; // The absolute URL where the root manifest was found
 }
 
 export class StaticDataLayerProvider implements DataLayerProvider {
   private config: StaticDataLayerConfig;
   private initialized: boolean = false;
   private courseUnpackers: Map<string, StaticDataUnpacker> = new Map();
+  private manifests: Record<string, StaticCourseManifest> = {};
 
   constructor(config: Partial<StaticDataLayerConfig>) {
     this.config = {
-      staticContentPath: config.staticContentPath || '/static-courses',
       localStoragePrefix: config.localStoragePrefix || 'skuilder-static',
-      manifests: config.manifests || {},
+      rootManifest: config.rootManifest || { dependencies: {} },
+      rootManifestUrl: config.rootManifestUrl || '/',
     };
   }
 
-  async initialize(): Promise<void> {
-    if (this.initialized) return;
+  private async resolveCourseDependencies(): Promise<void> {
+    logger.info('[StaticDataLayerProvider] Starting course dependency resolution...');
+    const rootManifest = this.config.rootManifest;
 
-    logger.info('Initializing static data layer provider');
+    for (const [courseName, courseUrl] of Object.entries(rootManifest.dependencies || {})) {
+      try {
+        logger.debug(`[StaticDataLayerProvider] Resolving dependency: ${courseName} from ${courseUrl}`);
+        
+        const courseManifestUrl = new URL(courseUrl as string, this.config.rootManifestUrl).href;
+        const courseJsonResponse = await fetch(courseManifestUrl);
+        if (!courseJsonResponse.ok) {
+          throw new Error(`Failed to fetch course manifest for ${courseName}`);
+        }
+        const courseJson = await courseJsonResponse.json();
+
+        if (courseJson.content && courseJson.content.manifest) {
+          const baseUrl = new URL('.', courseManifestUrl).href;
+          const finalManifestUrl = new URL(courseJson.content.manifest, courseManifestUrl).href;
 
-    // Load manifests for all courses
-    for (const [courseId, manifest] of Object.entries(this.config.manifests)) {
-      const unpacker = new StaticDataUnpacker(
-        manifest,
-        `${this.config.staticContentPath}/${courseId}`
-      );
-      this.courseUnpackers.set(courseId, unpacker);
+          const finalManifestResponse = await fetch(finalManifestUrl);
+          if (!finalManifestResponse.ok) {
+            throw new Error(`Failed to fetch final content manifest for ${courseName} at ${finalManifestUrl}`);
+          }
+          const finalManifest = await finalManifestResponse.json();
+          
+          this.manifests[courseName] = finalManifest;
+          const unpacker = new StaticDataUnpacker(finalManifest, baseUrl);
+          this.courseUnpackers.set(courseName, unpacker);
+
+          logger.info(`[StaticDataLayerProvider] Successfully resolved and prepared course: ${courseName}`);
+        }
+      } catch (e) {
+        logger.error(`[StaticDataLayerProvider] Failed to resolve dependency ${courseName}:`, e);
+        // Continue to next dependency
+      }
     }
+    logger.info('[StaticDataLayerProvider] Course dependency resolution complete.');
+  }
+
+  async initialize(): Promise<void> {
+    if (this.initialized) return;
 
+    logger.info('Initializing static data layer provider');
+    await this.resolveCourseDependencies();
     this.initialized = true;
   }
 
@@ -66,14 +107,14 @@ export class StaticDataLayerProvider implements DataLayerProvider {
   getCourseDB(courseId: string): CourseDBInterface {
     const unpacker = this.courseUnpackers.get(courseId);
     if (!unpacker) {
-      throw new Error(`Course ${courseId} not found in static data`);
+      throw new Error(`Course ${courseId} not found or failed to initialize in static data layer.`);
     }
-    const manifest = this.config.manifests[courseId];
+    const manifest = this.manifests[courseId];
     return new StaticCourseDB(courseId, unpacker, this.getUserDB(), manifest);
   }
 
   getCoursesDB(): CoursesDBInterface {
-    return new StaticCoursesDB(this.config.manifests);
+    return new StaticCoursesDB(this.manifests);
   }
 
   async getClassroomDB(
@@ -87,6 +128,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[]> {
@@ -114,22 +132,27 @@ export class StaticCourseDB implements CourseDBInterface {
     return { ok: true, id: cardId, rev: '1-static' };
   }
 
-  async getNewCards(limit?: number): Promise<StudySessionNewItem[]> {
-    // Simplified implementation - would need proper navigation strategy
-    const cardIds = await this.unpacker.queryByElo(1000, limit || 10);
-    return cardIds.map((cardId) => ({
-      status: 'new' as const,
-      qualifiedID: `${this.courseId}-${cardId}`,
-      cardID: cardId,
-      contentSourceType: 'course' as const,
-      contentSourceID: this.courseId,
-      courseID: this.courseId,
-    }));
+  async getNewCards(limit: number = 99): Promise<StudySessionNewItem[]> {
+    const activeCards = await this.userDB.getActiveCards();
+    return (
+      await this.getCardsCenteredAtELO({ limit: limit, elo: 'user' }, (c: QualifiedCardID) => {
+        if (activeCards.some((ac) => c.cardID === ac.cardID)) {
+          return false;
+        } else {
+          return true;
+        }
+      })
+    ).map((c) => {
+      return {
+        ...c,
+        status: 'new',
+      };
+    });
   }
 
   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 +171,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,
@@ -341,7 +369,7 @@ export class StaticCourseDB implements CourseDBInterface {
   // Navigation Strategy Manager implementation
   async getNavigationStrategy(_id: string): Promise<ContentNavigationStrategyData> {
     return {
-      id: 'ELO',
+      _id: 'NAVIGATION_STRATEGY-ELO',
       docType: DocType.NAVIGATION_STRATEGY,
       name: 'ELO',
       description: 'ELO-based navigation strategy',
@@ -390,4 +418,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/impl/static/coursesDB.ts

@@ -9,14 +9,18 @@ export class StaticCoursesDB implements CoursesDBInterface {
   constructor(private manifests: Record<string, StaticCourseManifest>) {}
 
   async getCourseConfig(courseId: string): Promise<CourseConfig> {
-    if (!this.manifests[courseId]) {
-      // throw new Error(`Course ${courseId} not found`);
-      logger.warn(`Course ${courseId} not found`);
-      return {} as CourseConfig; // Return empty config if course not found
+    const manifest = this.manifests[courseId];
+    if (!manifest) {
+      logger.warn(`Course manifest for ${courseId} not found`);
+      throw new Error(`Course ${courseId} not found`);
     }
 
-    // Would need to fetch the course config from static files
-    return {} as CourseConfig;
+    if (manifest.courseConfig) {
+      return manifest.courseConfig;
+    } else {
+      logger.warn(`Course config not found in manifest for course ${courseId}`);
+      throw new Error(`Course config not found for course ${courseId}`);
+    }
   }
 
   async getCourseList(): Promise<CourseConfig[]> {

package/src/pouch/index.ts

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

package/src/study/ItemQueue.ts

@@ -0,0 +1,58 @@
+export class ItemQueue<T> {
+  private q: T[] = [];
+  private seenCardIds: string[] = [];
+  private _dequeueCount: number = 0;
+  public get dequeueCount(): number {
+    return this._dequeueCount;
+  }
+
+  public add(item: T, cardId: string) {
+    if (this.seenCardIds.find((d) => d === cardId)) {
+      return; // do not re-add a card to the same queue
+    }
+
+    this.seenCardIds.push(cardId);
+    this.q.push(item);
+  }
+
+  public addAll(items: T[], cardIdExtractor: (item: T) => string) {
+    items.forEach((i) => this.add(i, cardIdExtractor(i)));
+  }
+
+  public get length() {
+    return this.q.length;
+  }
+
+  public peek(index: number): T {
+    return this.q[index];
+  }
+
+  public dequeue(cardIdExtractor?: (item: T) => string): T | null {
+    if (this.q.length !== 0) {
+      this._dequeueCount++;
+      const item = this.q.splice(0, 1)[0];
+
+      // Remove cardId from seenCardIds when dequeuing to allow re-queueing
+      if (cardIdExtractor) {
+        const cardId = cardIdExtractor(item);
+        const index = this.seenCardIds.indexOf(cardId);
+        if (index > -1) {
+          this.seenCardIds.splice(index, 1);
+        }
+      }
+
+      return item;
+    } else {
+      return null;
+    }
+  }
+
+  public get toString(): string {
+    return (
+      `${typeof this.q[0]}:\n` +
+      this.q
+        .map((i) => `\t${(i as any).courseID}+${(i as any).cardID}: ${(i as any).status}`)
+        .join('\n')
+    );
+  }
+}