@vue-skuilder/db 0.1.7 → 0.1.8-0

package/src/impl/couch/updateQueue.ts

@@ -12,7 +12,8 @@ export default class UpdateQueue extends Loggable {
     [index: string]: boolean;
   } = {};
 
-  private db: PouchDB.Database;
+  private readDB: PouchDB.Database; // Database for read operations
+  private writeDB: PouchDB.Database; // Database for write operations (local-first)
 
   public update<T extends PouchDB.Core.Document<object>>(
     id: PouchDB.Core.DocumentId,
@@ -27,21 +28,24 @@ export default class UpdateQueue extends Loggable {
     return this.applyUpdates<T>(id);
   }
 
-  constructor(db: PouchDB.Database) {
+  constructor(readDB: PouchDB.Database, writeDB?: PouchDB.Database) {
     super();
     // PouchDB.debug.enable('*');
-    this.db = db;
+    this.readDB = readDB;
+    this.writeDB = writeDB || readDB; // Default to readDB if writeDB not provided
     logger.debug(`UpdateQ initialized...`);
-    void this.db.info().then((i) => {
+    void this.readDB.info().then((i) => {
       logger.debug(`db info: ${JSON.stringify(i)}`);
     });
   }
 
-  private async applyUpdates<T extends PouchDB.Core.Document<object>>(id: string): Promise<T> {
+  private async applyUpdates<T extends PouchDB.Core.Document<object>>(
+    id: string
+  ): Promise<T & PouchDB.Core.GetMeta & PouchDB.Core.RevisionIdMeta> {
     logger.debug(`Applying updates on doc: ${id}`);
     if (this.inprogressUpdates[id]) {
       // console.log(`Updates in progress...`);
-      await this.db.info(); // stall for a round trip
+      await this.readDB.info(); // stall for a round trip
       // console.log(`Retrying...`);
       return this.applyUpdates<T>(id);
     } else {
@@ -49,7 +53,7 @@ export default class UpdateQueue extends Loggable {
         this.inprogressUpdates[id] = true;
 
         try {
-          let doc = await this.db.get<T>(id);
+          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];
@@ -66,7 +70,7 @@ export default class UpdateQueue extends Loggable {
           //   console.log(`${k}: ${typeof k}`);
           // }
           // console.log(`Applied updates to doc: ${JSON.stringify(doc)}`);
-          await this.db.put<T>(doc);
+          await this.writeDB.put<T>(doc);
           logger.debug(`Put doc: ${id}`);
 
           if (this.pendingUpdates[id].length === 0) {

package/src/impl/couch/user-course-relDB.ts

@@ -4,20 +4,18 @@ import {
   UserCourseSettings,
   UsrCrsDataInterface,
 } from '@db/core';
+
 import moment, { Moment } from 'moment';
-import { getStartAndEndKeys, REVIEW_PREFIX, REVIEW_TIME_FORMAT } from '.';
-import { CourseDB } from './courseDB';
-import { User } from './userDB';
+
+import { UserDBInterface } from '@db/core';
 import { logger } from '../../util/logger';
 
 export class UsrCrsData implements UsrCrsDataInterface {
-  private user: User;
-  private course: CourseDB;
+  private user: UserDBInterface;
   private _courseId: string;
 
-  constructor(user: User, courseId: string) {
+  constructor(user: UserDBInterface, courseId: string) {
     this.user = user;
-    this.course = new CourseDB(courseId, async () => this.user);
     this._courseId = courseId;
   }
 
@@ -47,32 +45,24 @@ export class UsrCrsData implements UsrCrsDataInterface {
     }
   }
   public updateCourseSettings(updates: UserCourseSetting[]): void {
-    void this.user.updateCourseSettings(this._courseId, updates);
+    // TODO: Add updateCourseSettings method to UserDBInterface
+    // For now, we'll need to cast to access the concrete implementation
+    if ('updateCourseSettings' in this.user) {
+      void (this.user as any).updateCourseSettings(this._courseId, updates);
+    }
   }
 
   private async getReviewstoDate(targetDate: Moment) {
-    const keys = getStartAndEndKeys(REVIEW_PREFIX);
-
-    const reviews = await this.user.remote().allDocs<ScheduledCard>({
-      startkey: keys.startkey,
-      endkey: keys.endkey,
-      include_docs: true,
-    });
+    // Use the interface method instead of direct database access
+    const allReviews = await this.user.getPendingReviews(this._courseId);
 
     logger.debug(
       `Fetching ${this.user.getUsername()}'s scheduled reviews for course ${this._courseId}.`
     );
-    return reviews.rows
-      .filter((r) => {
-        if (r.id.startsWith(REVIEW_PREFIX)) {
-          const date = moment.utc(r.id.substr(REVIEW_PREFIX.length), REVIEW_TIME_FORMAT);
-          if (targetDate.isAfter(date)) {
-            if (this._courseId === undefined || r.doc!.courseId === this._courseId) {
-              return true;
-            }
-          }
-        }
-      })
-      .map((r) => r.doc!);
+
+    return allReviews.filter((review: ScheduledCard) => {
+      const reviewTime = moment.utc(review.reviewTime);
+      return targetDate.isAfter(reviewTime);
+    });
   }
 }

package/src/impl/static/NoOpSyncStrategy.ts

@@ -17,6 +17,11 @@ export class NoOpSyncStrategy implements SyncStrategy {
     return getLocalUserDB(username);
   }
 
+  getWriteDB(username: string): PouchDB.Database {
+    // In static mode, always write to local database
+    return getLocalUserDB(username);
+  }
+
   startSync(_localDB: PouchDB.Database, _remoteDB: PouchDB.Database): void {
     // No-op - in static mode, local and remote are the same database instance
     // PouchDB sync with itself is harmless and efficient

package/src/impl/static/StaticDataUnpacker.ts

@@ -2,7 +2,7 @@
 
 import { StaticCourseManifest, ChunkMetadata } from '../../util/packer/types';
 import { logger } from '../../util/logger';
-import { DocType } from '@db/core';
+import { DocType, DocTypePrefixes } from '@db/core';
 
 // Browser-compatible path utilities
 const pathUtils = {
@@ -151,57 +151,38 @@ export class StaticDataUnpacker {
     return (await this.loadIndex('tags')) as TagsIndex;
   }
 
+  private getDocTypeFromId(id: string): DocType | undefined {
+    for (const docTypeKey in DocTypePrefixes) {
+      const prefix = DocTypePrefixes[docTypeKey as DocType];
+      if (id.startsWith(`${prefix}-`)) {
+        return docTypeKey as DocType;
+      }
+    }
+    return undefined;
+  }
+
   /**
    * Find which chunk contains a specific document ID
    */
   private async findChunkForDocument(docId: string): Promise<ChunkMetadata | undefined> {
-    // Determine document type from ID pattern by checking all DocType enum members
-    let expectedDocType: DocType | undefined = undefined;
-
-    // Check for ID prefixes matching any DocType enum value
-    for (const docType of Object.values(DocType)) {
-      if (docId.startsWith(`${docType}-`)) {
-        expectedDocType = docType;
-        break;
-      }
-    }
+    const expectedDocType = this.getDocTypeFromId(docId);
 
-    if (expectedDocType !== undefined) {
-      // Use chunk filtering by docType for documents with recognized prefixes
+    if (expectedDocType) {
       const typeChunks = this.manifest.chunks.filter((c) => c.docType === expectedDocType);
 
       for (const chunk of typeChunks) {
         if (docId >= chunk.startKey && docId <= chunk.endKey) {
-          // Verify document actually exists in chunk
           const exists = await this.verifyDocumentInChunk(docId, chunk);
           if (exists) {
             return chunk;
           }
         }
       }
-
-      return undefined;
     } else {
-      // Fall back to trying all chunk types with strict verification
-      // Since card IDs and displayable data IDs can overlap in range, we need to verify actual existence
-
-      // First try DISPLAYABLE_DATA chunks (most likely for documents without prefixes)
-      const displayableChunks = this.manifest.chunks.filter(
-        (c) => c.docType === 'DISPLAYABLE_DATA'
-      );
-      for (const chunk of displayableChunks) {
-        if (docId >= chunk.startKey && docId <= chunk.endKey) {
-          // Verify document actually exists in chunk
-          const exists = await this.verifyDocumentInChunk(docId, chunk);
-          if (exists) {
-            return chunk;
-          }
-        }
-      }
-
-      // Then try CARD chunks (for legacy card IDs without prefixes)
-      const cardChunks = this.manifest.chunks.filter((c) => c.docType === 'CARD');
-      for (const chunk of cardChunks) {
+      // Fallback for documents without recognized prefixes (e.g., CourseConfig, or old documents)
+      // This part remains for backward compatibility and non-prefixed documents.
+      // It's less efficient but necessary if not all document types are prefixed.
+      for (const chunk of this.manifest.chunks) {
         if (docId >= chunk.startKey && docId <= chunk.endKey) {
           // Verify document actually exists in chunk
           const exists = await this.verifyDocumentInChunk(docId, chunk);
@@ -227,6 +208,7 @@ export class StaticDataUnpacker {
 
       return undefined;
     }
+    return undefined;
   }
 
   /**

package/src/impl/static/courseDB.ts

@@ -15,6 +15,7 @@ import { DataLayerResult } from '../../core/types/db';
 import { ContentNavigationStrategyData } from '../../core/types/contentNavigationStrategy';
 import { ScheduledCard } from '../../core/types/user';
 import { Navigators } from '../../core/navigators';
+import { logger } from '../../util/logger';
 
 export class StaticCourseDB implements CourseDBInterface {
   constructor(
@@ -41,10 +42,15 @@ export class StaticCourseDB implements CourseDBInterface {
   }
 
   async getCourseInfo(): Promise<CourseInfo> {
-    // This would need to be pre-computed in the manifest
+    // Count only cards, not all documents
+    // Use chunks metadata to count card documents specifically
+    const cardCount = this.manifest.chunks
+      .filter((chunk) => chunk.docType === DocType.CARD)
+      .reduce((total, chunk) => total + chunk.documentCount, 0);
+
     return {
-      cardCount: 0, // Would come from manifest
-      registeredUsers: 0,
+      cardCount,
+      registeredUsers: 0, // Always 0 in static mode
     };
   }
 
@@ -158,13 +164,61 @@ export class StaticCourseDB implements CourseDBInterface {
     }));
   }
 
-  async getAppliedTags(_cardId: string): Promise<PouchDB.Query.Response<TagStub>> {
-    // Would need to query the tag index
-    return {
-      total_rows: 0,
-      offset: 0,
-      rows: [],
-    };
+  async getAppliedTags(cardId: string): Promise<PouchDB.Query.Response<TagStub>> {
+    try {
+      const tagsIndex = await this.unpacker.getTagsIndex();
+      const cardTags = tagsIndex.byCard[cardId] || [];
+
+      const rows = await Promise.all(
+        cardTags.map(async (tagName) => {
+          const tagId = `${DocType.TAG}-${tagName}`;
+
+          try {
+            // Try to get the full tag document
+            const tagDoc = await this.unpacker.getDocument(tagId);
+            return {
+              id: tagId,
+              key: cardId,
+              value: {
+                name: tagDoc.name,
+                snippet: tagDoc.snippet,
+                count: tagDoc.taggedCards?.length || 0,
+              },
+            };
+          } catch (error) {
+            if (error && (error as PouchDB.Core.Error).status === 404) {
+              logger.warn(`Tag document not found for ${tagName}, creating stub`);
+            } else {
+              logger.error(`Error getting tag document for ${tagName}:`, error);
+              throw error;
+            }
+            // If tag document not found, create a minimal stub
+            return {
+              id: tagId,
+              key: cardId,
+              value: {
+                name: tagName,
+                snippet: `Tag: ${tagName}`,
+                count: tagsIndex.byTag[tagName]?.length || 0,
+              },
+            };
+          }
+        })
+      );
+
+      return {
+        total_rows: rows.length,
+        offset: 0,
+        rows,
+      };
+    } catch (error) {
+      logger.error(`Error getting applied tags for card ${cardId}:`, error);
+      return {
+        total_rows: 0,
+        offset: 0,
+        rows: [],
+      };
+    }
   }
 
   async addTagToCard(_cardId: string, _tagId: string): Promise<PouchDB.Core.Response> {
@@ -188,12 +242,76 @@ export class StaticCourseDB implements CourseDBInterface {
   }
 
   async getCourseTagStubs(): Promise<PouchDB.Core.AllDocsResponse<Tag>> {
-    // Would query all tag documents
-    return {
-      total_rows: 0,
-      offset: 0,
-      rows: [],
-    };
+    try {
+      const tagsIndex = await this.unpacker.getTagsIndex();
+
+      if (!tagsIndex || !tagsIndex.byTag) {
+        logger.warn('Tags index not found or empty');
+        return {
+          total_rows: 0,
+          offset: 0,
+          rows: [],
+        };
+      }
+
+      // Create tag stubs from the index
+      const tagNames = Object.keys(tagsIndex.byTag);
+      const rows = await Promise.all(
+        tagNames.map(async (tagName) => {
+          const cardIds = tagsIndex.byTag[tagName] || [];
+          const tagId = `${DocType.TAG}-${tagName}`;
+
+          try {
+            // Try to get the full tag document
+            const tagDoc = await this.unpacker.getDocument(tagId);
+            return {
+              id: tagId,
+              key: tagId,
+              value: { rev: '1-static' },
+              doc: tagDoc,
+            };
+          } catch (error) {
+            // If tag document not found, create a minimal stub
+            if (error && (error as PouchDB.Core.Error).status === 404) {
+              logger.warn(`Tag document not found for ${tagName}, creating stub`);
+              const stubDoc = {
+                _id: tagId,
+                _rev: '1-static',
+                course: this.courseId,
+                docType: DocType.TAG,
+                name: tagName,
+                snippet: `Tag: ${tagName}`,
+                wiki: '',
+                taggedCards: cardIds,
+                author: 'system',
+              };
+              return {
+                id: tagId,
+                key: tagId,
+                value: { rev: '1-static' },
+                doc: stubDoc,
+              };
+            } else {
+              logger.error(`Error getting tag document for ${tagName}:`, error);
+              throw error;
+            }
+          }
+        })
+      );
+
+      return {
+        total_rows: rows.length,
+        offset: 0,
+        rows,
+      };
+    } catch (error) {
+      logger.error('Failed to get course tag stubs:', error);
+      return {
+        total_rows: 0,
+        offset: 0,
+        rows: [],
+      };
+    }
   }
 
   async addNote(
@@ -256,7 +374,7 @@ export class StaticCourseDB implements CourseDBInterface {
   }
 
   // Attachment helper methods (internal use, not part of interface)
-  
+
   /**
    * Get attachment URL for a document and attachment name
    * Internal helper method for static attachment serving

package/src/util/migrator/FileSystemAdapter.ts

@@ -26,11 +26,31 @@ export interface FileSystemAdapter {
    */
   stat(filePath: string): Promise<FileStats>;
 
+  /**
+   * Write text data to a file
+   */
+  writeFile(filePath: string, data: string | Buffer): Promise<void>;
+
+  /**
+   * Write JSON data to a file with formatting
+   */
+  writeJson(filePath: string, data: any, options?: { spaces?: number }): Promise<void>;
+
+  /**
+   * Ensure a directory exists, creating it and parent directories if needed
+   */
+  ensureDir(dirPath: string): Promise<void>;
+
   /**
    * Join path segments into a complete path
    */
   joinPath(...segments: string[]): string;
 
+  /**
+   * Get the directory name of a path
+   */
+  dirname(filePath: string): string;
+
   /**
    * Check if a path is absolute
    */

package/src/util/migrator/StaticToCouchDBMigrator.ts

@@ -425,6 +425,8 @@ export class StaticToCouchDBMigrator {
           const cleanDoc = { ...doc };
           // Remove _rev if present (CouchDB will assign new revision)
           delete cleanDoc._rev;
+          // Remove _attachments - these are uploaded separately in Phase 5
+          delete cleanDoc._attachments;
 
           return cleanDoc;
         });
@@ -575,10 +577,14 @@ export class StaticToCouchDBMigrator {
         }
       }
 
+      // Get current document revision (needed for putAttachment)
+      const doc = await db.get(docId);
+      
       // Upload to CouchDB
       await db.putAttachment(
         docId,
         attachmentName,
+        doc._rev,
         attachmentData as any, // PouchDB accepts both ArrayBuffer and Buffer
         attachmentMeta.content_type
       );

package/src/util/packer/CouchDBToStaticPacker.ts

@@ -14,6 +14,7 @@ import {
   StaticCourseManifest,
   AttachmentData,
 } from './types';
+import { FileSystemAdapter } from '../migrator/FileSystemAdapter';
 
 export class CouchDBToStaticPacker {
   private config: PackerConfig;
@@ -86,6 +87,94 @@ export class CouchDBToStaticPacker {
     };
   }
 
+  /**
+   * Pack a CouchDB course database and write the static files to disk
+   */
+  async packCourseToFiles(
+    sourceDB: PouchDB.Database, 
+    courseId: string, 
+    outputDir: string, 
+    fsAdapter: FileSystemAdapter
+  ): Promise<{ 
+    manifest: StaticCourseManifest; 
+    filesWritten: number; 
+    attachmentsFound: number; 
+  }> {
+    logger.info(`Packing course ${courseId} to files in ${outputDir}`);
+    
+    // First, pack the course data
+    const packedData = await this.packCourse(sourceDB, courseId);
+    
+    // Write the files using the FileSystemAdapter
+    const filesWritten = await this.writePackedDataToFiles(packedData, outputDir, fsAdapter);
+    
+    return {
+      manifest: packedData.manifest,
+      filesWritten,
+      attachmentsFound: packedData.attachments ? packedData.attachments.size : 0,
+    };
+  }
+
+  /**
+   * Write packed course data to files using FileSystemAdapter
+   */
+  private async writePackedDataToFiles(
+    packedData: PackedCourseData,
+    outputDir: string,
+    fsAdapter: FileSystemAdapter
+  ): Promise<number> {
+    let totalFiles = 0;
+    
+    // Ensure output directory exists
+    await fsAdapter.ensureDir(outputDir);
+    
+    // Write manifest
+    const manifestPath = fsAdapter.joinPath(outputDir, 'manifest.json');
+    await fsAdapter.writeJson(manifestPath, packedData.manifest, { spaces: 2 });
+    totalFiles++;
+    logger.info(`Wrote manifest: ${manifestPath}`);
+    
+    // Create subdirectories
+    const chunksDir = fsAdapter.joinPath(outputDir, 'chunks');
+    const indicesDir = fsAdapter.joinPath(outputDir, 'indices');
+    await fsAdapter.ensureDir(chunksDir);
+    await fsAdapter.ensureDir(indicesDir);
+    
+    // Write chunks
+    for (const [chunkId, chunkData] of packedData.chunks) {
+      const chunkPath = fsAdapter.joinPath(chunksDir, `${chunkId}.json`);
+      await fsAdapter.writeJson(chunkPath, chunkData);
+      totalFiles++;
+    }
+    logger.info(`Wrote ${packedData.chunks.size} chunk files`);
+    
+    // Write indices
+    for (const [indexName, indexData] of packedData.indices) {
+      const indexPath = fsAdapter.joinPath(indicesDir, `${indexName}.json`);
+      await fsAdapter.writeJson(indexPath, indexData, { spaces: 2 });
+      totalFiles++;
+    }
+    logger.info(`Wrote ${packedData.indices.size} index files`);
+    
+    // Write attachments
+    if (packedData.attachments && packedData.attachments.size > 0) {
+      for (const [attachmentPath, attachmentData] of packedData.attachments) {
+        const fullAttachmentPath = fsAdapter.joinPath(outputDir, attachmentPath);
+        
+        // Ensure attachment directory exists
+        const attachmentDir = fsAdapter.dirname(fullAttachmentPath);
+        await fsAdapter.ensureDir(attachmentDir);
+        
+        // Write binary file
+        await fsAdapter.writeFile(fullAttachmentPath, attachmentData.buffer);
+        totalFiles++;
+      }
+      logger.info(`Wrote ${packedData.attachments.size} attachment files`);
+    }
+    
+    return totalFiles;
+  }
+
   private async extractCourseConfig(db: PouchDB.Database): Promise<CourseConfig> {
     try {
       return await db.get<CourseConfig>('CourseConfig');
@@ -322,11 +411,12 @@ export class CouchDBToStaticPacker {
 
     try {
       const designDocId = designDoc._id; // e.g., "_design/elo"
-      const viewPath = `${designDocId}/${viewName}`;
+      const designDocName = designDocId.replace('_design/', ''); // Extract just "elo"
+      const viewPath = `${designDocName}/${viewName}`;
       
       logger.info(`Querying CouchDB view: ${viewPath}`);
       
-      // Query the view directly from CouchDB
+      // Query the view directly from CouchDB using PouchDB format: "designDocName/viewName"
       const viewResults = await this.sourceDB.query(viewPath, {
         include_docs: false,
       });