@vue-skuilder/db 0.1.4 → 0.1.5

package/src/impl/static/userDB.ts

@@ -0,0 +1,179 @@
+// packages/db/src/impl/static/userDB.ts
+
+import { UserDBInterface } from '../../core/interfaces';
+
+export class StaticUserDB implements UserDBInterface {
+  constructor(_prefix: string) {}
+
+  isLoggedIn(): boolean {
+    return false; // Always guest in static mode
+  }
+
+  getUsername(): string {
+    return 'Guest';
+  }
+
+  async createAccount(_username: string, _password: string): Promise<any> {
+    throw new Error('Cannot create accounts in static mode');
+  }
+
+  async login(_username: string, _password: string): Promise<any> {
+    throw new Error('Cannot login in static mode');
+  }
+
+  async logout(): Promise<any> {
+    return { ok: true };
+  }
+
+  async getConfig(): Promise<any> {
+    return {}; // Default empty config
+  }
+
+  async setConfig(_config: any): Promise<void> {
+    // No-op in static mode
+  }
+
+  async putCardRecord<T>(_record: T): Promise<any> {
+    throw new Error('Cannot record card interactions in static mode');
+  }
+
+  async getSeenCards(_courseId?: string): Promise<string[]> {
+    return []; // No seen cards in static mode
+  }
+
+  async getActiveCards(): Promise<string[]> {
+    return []; // No active cards in static mode
+  }
+
+  async registerForCourse(_courseId: string, _previewMode?: boolean): Promise<any> {
+    return { ok: true, id: 'static-registration', rev: '1-static' };
+  }
+
+  async getCourseRegistrationsDoc(): Promise<any> {
+    return { courses: [] }; // Empty registrations
+  }
+
+  async deregisterFromCourse(_courseId: string): Promise<any> {
+    return { ok: true };
+  }
+
+  async addScheduledCard(_card: any): Promise<any> {
+    throw new Error('Cannot schedule cards in static mode');
+  }
+
+  async removeScheduledCard(_qualifiedID: string): Promise<any> {
+    throw new Error('Cannot remove scheduled cards in static mode');
+  }
+
+  async getScheduledCards(): Promise<any[]> {
+    return []; // No scheduled cards in static mode
+  }
+
+  async addActivityRecord(_record: any): Promise<any> {
+    throw new Error('Cannot add activity records in static mode');
+  }
+
+  async getActivityRecords(_courseId?: string): Promise<any[]> {
+    return []; // No activity records in static mode
+  }
+
+  async setUserElo(_courseId: string, _elo: any): Promise<any> {
+    throw new Error('Cannot set user ELO in static mode');
+  }
+
+  async getUserElo(_courseId: string): Promise<any> {
+    return { global: { score: 1000, count: 0 }, tags: {}, misc: {} };
+  }
+
+  async updateDocument(_doc: any): Promise<any> {
+    throw new Error('Cannot update documents in static mode');
+  }
+
+  async dropCourse(_courseId: string, _dropStatus?: string): Promise<any> {
+    return { ok: true };
+  }
+
+  async getCourseRegDoc(_courseId: string): Promise<any> {
+    return { courseID: _courseId, status: 'active' };
+  }
+
+  async getActiveCourses(): Promise<any[]> {
+    return []; // No active courses in static mode
+  }
+
+  async getPendingReviews(_courseId?: string): Promise<any[]> {
+    return []; // No pending reviews in static mode
+  }
+
+  async getScheduledReviewCount(_courseId: string): Promise<number> {
+    return 0; // No scheduled reviews in static mode
+  }
+
+  async getReviewstoDate(_date: any, _courseId?: string): Promise<any[]> {
+    return []; // No reviews in static mode
+  }
+
+  async addCardToReviews(_card: any): Promise<any> {
+    throw new Error('Cannot add cards to reviews in static mode');
+  }
+
+  async removeCardFromReviews(_qualifiedID: string): Promise<any> {
+    throw new Error('Cannot remove cards from reviews in static mode');
+  }
+
+  async scheduleCardReview(_card: any): Promise<any> {
+    throw new Error('Cannot schedule card reviews in static mode');
+  }
+
+  async removeScheduledCardReview(_qualifiedID: string): Promise<any> {
+    throw new Error('Cannot remove scheduled card reviews in static mode');
+  }
+
+  async registerForClassroom(_classId: string, _type: string): Promise<any> {
+    throw new Error('Cannot register for classrooms in static mode');
+  }
+
+  async dropFromClassroom(_classId: string): Promise<any> {
+    throw new Error('Cannot drop from classrooms in static mode');
+  }
+
+  async getClassroomRegistrations(): Promise<any[]> {
+    return []; // No classroom registrations in static mode
+  }
+
+  async syncUp(): Promise<any> {
+    return { ok: true }; // No sync needed in static mode
+  }
+
+  async syncDown(): Promise<any> {
+    return { ok: true }; // No sync needed in static mode
+  }
+
+  async replicateToRemote(): Promise<any> {
+    return { ok: true }; // No replication in static mode
+  }
+
+  async replicateFromRemote(): Promise<any> {
+    return { ok: true }; // No replication in static mode
+  }
+
+  async getUserClassrooms(): Promise<{ registrations: any[] }> {
+    return { registrations: [] }; // No classrooms in static mode
+  }
+
+  async getActiveClasses(): Promise<any[]> {
+    return []; // No active classes in static mode
+  }
+
+  async updateUserElo(_courseId: string, _elo: any): Promise<any> {
+    throw new Error('Cannot update user ELO in static mode');
+  }
+
+  async getCourseInterface(_courseId: string): Promise<any> {
+    throw new Error('Cannot get course interface in static mode');
+  }
+
+  async update(_doc: any): Promise<any> {
+    throw new Error('Cannot update user documents in static mode');
+  }
+}

package/src/index.ts

@@ -1,6 +1,6 @@
 export * from './core';
 
-export { default as CourseLookup } from './impl/pouch/courseLookupDB';
+export { default as CourseLookup } from './impl/couch/courseLookupDB';
 
 export * from './study';
 

package/src/study/SessionController.ts

@@ -5,11 +5,11 @@ import {
   StudySessionItem,
   StudySessionNewItem,
   StudySessionReviewItem,
-} from '@/impl/pouch';
+} from '@db/impl/couch';
 
-import { CardRecord } from '@/core';
-import { Loggable } from '@/util';
-import { ScheduledCard } from '@/core/types/user';
+import { CardRecord } from '@db/core';
+import { Loggable } from '@db/util';
+import { ScheduledCard } from '@db/core/types/user';
 
 function randomInt(min: number, max: number): number {
   return Math.floor(Math.random() * (max - min + 1)) + min;

package/src/study/SpacedRepetition.ts

@@ -1,6 +1,6 @@
-import { CardHistory, CardRecord, QuestionRecord } from '@/core/types/types-legacy';
-import { areQuestionRecords } from '@/core/util';
-import { Update } from '@/impl/pouch/updateQueue';
+import { CardHistory, CardRecord, QuestionRecord } from '@db/core/types/types-legacy';
+import { areQuestionRecords } from '@db/core/util';
+import { Update } from '@db/impl/couch/updateQueue';
 import moment from 'moment';
 import { logger } from '../util/logger';
 

package/src/study/getCardDataShape.ts

@@ -1,7 +1,7 @@
 import { allCourses } from '@vue-skuilder/courses';
 import { log, NameSpacer, CourseConfig, DataShape } from '@vue-skuilder/common';
-import { CardData, DisplayableData } from '@/core';
-import { getCourseDB } from '@/impl/pouch/courseAPI';
+import { CardData, DisplayableData } from '@db/core';
+import { getCourseDB } from '@db/impl/couch/courseAPI';
 
 export async function getCardDataShape(courseID: string, cardID: string) {
   const dataShapes: DataShape[] = [];

package/src/util/index.ts

@@ -1 +1,2 @@
 export * from './Loggable';
+export * from './packer';

package/src/util/packer/CouchDBToStaticPacker.ts

@@ -0,0 +1,349 @@
+// packages/db/src/util/packer/CouchDBToStaticPacker.ts
+
+import { CardData, DocType, Tag } from '../../core/types/types-legacy';
+import { logger } from '../logger';
+// CourseConfig interface - simplified for packer use
+
+import { CourseConfig } from '@vue-skuilder/common';
+import {
+  ChunkMetadata,
+  DesignDocument,
+  IndexMetadata,
+  PackedCourseData,
+  PackerConfig,
+  StaticCourseManifest,
+} from './types';
+
+export class CouchDBToStaticPacker {
+  private config: PackerConfig;
+
+  constructor(config: Partial<PackerConfig> = {}) {
+    this.config = {
+      chunkSize: 1000,
+      includeAttachments: true,
+      ...config,
+    };
+  }
+
+  /**
+   * Pack a CouchDB course database into static data structures
+   */
+  async packCourse(sourceDB: PouchDB.Database, courseId: string): Promise<PackedCourseData> {
+    logger.info(`Starting static pack for course: ${courseId}`);
+
+    const manifest: StaticCourseManifest = {
+      version: '1.0.0',
+      courseId,
+      courseName: '',
+      courseConfig: null,
+      lastUpdated: new Date().toISOString(),
+      documentCount: 0,
+      chunks: [],
+      indices: [],
+      designDocs: [],
+    };
+
+    // 1. Extract course config
+    const courseConfig = await this.extractCourseConfig(sourceDB);
+    manifest.courseName = courseConfig.name;
+    manifest.courseConfig = courseConfig;
+
+    // 2. Extract and process design documents
+    manifest.designDocs = await this.extractDesignDocs(sourceDB);
+
+    // 3. Extract all documents by type and create chunks
+    const docsByType = await this.extractDocumentsByType(sourceDB);
+
+    // 4. Create chunks and prepare chunk data
+    const chunks = new Map<string, any[]>();
+    for (const [docType, docs] of Object.entries(docsByType)) {
+      const chunkMetadata = this.createChunks(docs, docType as DocType);
+      manifest.chunks.push(...chunkMetadata);
+      manifest.documentCount += docs.length;
+
+      // Prepare chunk data
+      this.prepareChunkData(chunkMetadata, docs, chunks);
+    }
+
+    // 5. Build indices
+    const indices = new Map<string, any>();
+    manifest.indices = await this.buildIndices(docsByType, manifest.designDocs, indices);
+
+    return {
+      manifest,
+      chunks,
+      indices,
+    };
+  }
+
+  private async extractCourseConfig(db: PouchDB.Database): Promise<CourseConfig> {
+    try {
+      return await db.get<CourseConfig>('CourseConfig');
+    } catch (error) {
+      logger.error('Failed to extract course config:', error);
+      throw new Error('Course config not found');
+    }
+  }
+
+  private async extractDesignDocs(db: PouchDB.Database): Promise<DesignDocument[]> {
+    const result = await db.allDocs({
+      startkey: '_design/',
+      endkey: '_design/\ufff0',
+      include_docs: true,
+    });
+
+    return result.rows.map((row) => ({
+      _id: row.id,
+      views: (row.doc as any).views || {},
+    }));
+  }
+
+  private async extractDocumentsByType(db: PouchDB.Database): Promise<Record<DocType, any[]>> {
+    const allDocs = await db.allDocs({ include_docs: true });
+    const docsByType: Record<string, any[]> = {};
+
+    for (const row of allDocs.rows) {
+      if (row.id.startsWith('_')) continue; // Skip design docs
+
+      const doc = row.doc as any;
+      if (doc.docType) {
+        if (!docsByType[doc.docType]) {
+          docsByType[doc.docType] = [];
+        }
+        docsByType[doc.docType].push(doc);
+      }
+    }
+
+    return docsByType as Record<DocType, any[]>;
+  }
+
+  private createChunks(docs: any[], docType: DocType): ChunkMetadata[] {
+    const chunks: ChunkMetadata[] = [];
+    const sortedDocs = docs.sort((a, b) => a._id.localeCompare(b._id));
+
+    for (let i = 0; i < sortedDocs.length; i += this.config.chunkSize) {
+      const chunk = sortedDocs.slice(i, i + this.config.chunkSize);
+      const chunkId = `${docType}-${String(Math.floor(i / this.config.chunkSize)).padStart(4, '0')}`;
+
+      chunks.push({
+        id: chunkId,
+        docType,
+        startKey: chunk[0]._id,
+        endKey: chunk[chunk.length - 1]._id,
+        documentCount: chunk.length,
+        path: `chunks/${chunkId}.json`,
+      });
+    }
+
+    return chunks;
+  }
+
+  private prepareChunkData(
+    chunkMetadata: ChunkMetadata[],
+    docs: any[],
+    chunks: Map<string, any[]>
+  ): void {
+    const sortedDocs = docs.sort((a, b) => a._id.localeCompare(b._id));
+
+    for (const chunk of chunkMetadata) {
+      const chunkDocs = sortedDocs.filter(
+        (doc) => doc._id >= chunk.startKey && doc._id <= chunk.endKey
+      );
+
+      // Clean documents for storage
+      const cleanedDocs = chunkDocs.map((doc) => {
+        const cleaned = { ...doc };
+        delete cleaned._rev; // Remove revision info
+        if (!this.config.includeAttachments) {
+          delete cleaned._attachments;
+        }
+        return cleaned;
+      });
+
+      chunks.set(chunk.id, cleanedDocs);
+    }
+  }
+
+  private async buildIndices(
+    docsByType: Record<DocType, any[]>,
+    designDocs: DesignDocument[],
+    indices: Map<string, any>
+  ): Promise<IndexMetadata[]> {
+    const indexMetadata: IndexMetadata[] = [];
+
+    // Build ELO index
+    if (docsByType[DocType.CARD]) {
+      const eloIndexMeta = await this.buildEloIndex(
+        docsByType[DocType.CARD] as CardData[],
+        indices
+      );
+      indexMetadata.push(eloIndexMeta);
+    }
+
+    // Build tag indices
+    if (docsByType[DocType.TAG]) {
+      const tagIndexMeta = await this.buildTagIndex(docsByType[DocType.TAG] as Tag[], indices);
+      indexMetadata.push(tagIndexMeta);
+    }
+
+    // Build indices from design documents
+    for (const designDoc of designDocs) {
+      for (const [viewName, viewDef] of Object.entries(designDoc.views)) {
+        if (viewDef.map) {
+          const indexMeta = await this.buildViewIndex(
+            viewName,
+            viewDef.map,
+            docsByType,
+            indices,
+            viewDef.reduce
+          );
+          if (indexMeta) indexMetadata.push(indexMeta);
+        }
+      }
+    }
+
+    return indexMetadata;
+  }
+
+  private async buildEloIndex(
+    cards: CardData[],
+    indices: Map<string, any>
+  ): Promise<IndexMetadata> {
+    // Build a B-tree like structure for ELO queries
+    const eloIndex: Array<{ elo: number; cardId: string }> = [];
+
+    for (const card of cards) {
+      if (card.elo?.global?.score) {
+        eloIndex.push({
+          elo: card.elo.global.score,
+          cardId: (card as any)._id,
+        });
+      }
+    }
+
+    // Sort by ELO for efficient range queries
+    eloIndex.sort((a, b) => a.elo - b.elo);
+
+    // Create buckets for faster lookup
+    const buckets: Record<number, string[]> = {};
+    const bucketSize = 50; // ELO points per bucket
+
+    for (const entry of eloIndex) {
+      const bucket = Math.floor(entry.elo / bucketSize) * bucketSize;
+      if (!buckets[bucket]) buckets[bucket] = [];
+      buckets[bucket].push(entry.cardId);
+    }
+
+    // Store the index data
+    indices.set('elo', {
+      sorted: eloIndex,
+      buckets: buckets,
+      stats: {
+        min: eloIndex[0]?.elo || 0,
+        max: eloIndex[eloIndex.length - 1]?.elo || 0,
+        count: eloIndex.length,
+      },
+    });
+
+    return {
+      name: 'elo',
+      type: 'btree',
+      path: 'indices/elo.json',
+    };
+  }
+
+  private async buildTagIndex(tags: Tag[], indices: Map<string, any>): Promise<IndexMetadata> {
+    // Build inverted index for tags
+    const tagIndex: Record<
+      string,
+      {
+        cardIds: string[];
+        snippet: string;
+        count: number;
+      }
+    > = {};
+
+    for (const tag of tags) {
+      tagIndex[tag.name] = {
+        cardIds: tag.taggedCards,
+        snippet: tag.snippet,
+        count: tag.taggedCards.length,
+      };
+    }
+
+    // Also build a reverse index (card -> tags)
+    const cardToTags: Record<string, string[]> = {};
+    for (const tag of tags) {
+      for (const cardId of tag.taggedCards) {
+        if (!cardToTags[cardId]) cardToTags[cardId] = [];
+        cardToTags[cardId].push(tag.name);
+      }
+    }
+
+    indices.set('tags', {
+      byTag: tagIndex,
+      byCard: cardToTags,
+    });
+
+    return {
+      name: 'tags',
+      type: 'hash',
+      path: 'indices/tags.json',
+    };
+  }
+
+  private async buildViewIndex(
+    viewName: string,
+    mapFunction: string,
+    docsByType: Record<DocType, any[]>,
+    indices: Map<string, any>,
+    _reduceFunction?: string
+  ): Promise<IndexMetadata | null> {
+    try {
+      // Parse and execute the map function in a sandboxed way
+      // This is a simplified version - in production you'd want proper sandboxing
+      const viewResults: Array<{ key: any; value: any; id: string }> = [];
+
+      // Create a safe emit function
+      const emit = (key: any, value: any) => {
+        viewResults.push({ key, value, id: currentDocId });
+      };
+
+      let currentDocId = '';
+
+      // Create the map function
+      // Note: This is simplified and would need proper sandboxing in production
+      const mapFn = new Function('doc', 'emit', mapFunction);
+
+      // Run map function on all documents
+      for (const docs of Object.values(docsByType)) {
+        for (const doc of docs) {
+          currentDocId = doc._id;
+          try {
+            mapFn(doc, emit);
+          } catch (error) {
+            logger.warn(`Map function error for doc ${doc._id}:`, error);
+          }
+        }
+      }
+
+      // Sort by key for efficient querying
+      viewResults.sort((a, b) => {
+        if (a.key < b.key) return -1;
+        if (a.key > b.key) return 1;
+        return 0;
+      });
+
+      indices.set(`view-${viewName}`, viewResults);
+
+      return {
+        name: `view-${viewName}`,
+        type: 'btree',
+        path: `indices/view-${viewName}.json`,
+      };
+    } catch (error) {
+      logger.error(`Failed to build index for view ${viewName}:`, error);
+      return null;
+    }
+  }
+}

package/src/util/packer/index.ts

@@ -0,0 +1,4 @@
+// packages/db/src/util/packer/index.ts
+
+export * from './types.js';
+export { CouchDBToStaticPacker } from './CouchDBToStaticPacker.js';

package/src/util/packer/types.ts

@@ -0,0 +1,52 @@
+// packages/db/src/util/packer/types.ts
+
+import { CourseConfig } from '@vue-skuilder/common';
+import { DocType } from '../../core/types/types-legacy';
+
+export interface StaticCourseManifest {
+  version: string;
+  courseId: string;
+  courseName: string;
+  courseConfig: CourseConfig | null; // Full CourseConfig object
+  lastUpdated: string;
+  documentCount: number;
+  chunks: ChunkMetadata[];
+  indices: IndexMetadata[];
+  designDocs: DesignDocument[];
+}
+
+export interface ChunkMetadata {
+  id: string;
+  docType: DocType;
+  startKey: string;
+  endKey: string;
+  documentCount: number;
+  path: string; // Relative path for file writing
+}
+
+export interface IndexMetadata {
+  name: string;
+  type: 'btree' | 'hash' | 'spatial';
+  path: string; // Relative path for file writing
+}
+
+export interface DesignDocument {
+  _id: string;
+  views: {
+    [viewName: string]: {
+      map: string;
+      reduce?: string;
+    };
+  };
+}
+
+export interface PackerConfig {
+  chunkSize: number;
+  includeAttachments: boolean;
+}
+
+export interface PackedCourseData {
+  manifest: StaticCourseManifest;
+  chunks: Map<string, any[]>; // chunkId -> documents
+  indices: Map<string, any>; // indexName -> index data
+}

package/tsconfig.json

@@ -1,12 +1,9 @@
 {
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "noEmit": true,
-    "paths": {
-      "@/*": ["./src/*"]
-    }
-  },
-  "include": ["src"]
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "noEmit": true
+    },
+    "include": ["src"]
 }

package/tsup.config.ts

@@ -4,7 +4,9 @@ export default defineConfig({
   entry: [
     'src/index.ts',
     'src/core/index.ts',
-    'src/pouch/index.ts'
+    'src/impl/couch/index.ts',
+    'src/impl/static/index.ts',
+    'src/util/packer/index.ts',
   ],
   format: ['cjs', 'esm'],
   dts: true,
@@ -12,6 +14,6 @@ export default defineConfig({
   sourcemap: true,
   clean: true,
   outExtension: ({ format }) => ({
-    js: format === 'esm' ? '.mjs' : '.js'
-  })
+    js: format === 'esm' ? '.mjs' : '.js',
+  }),
 });