@vue-skuilder/db 0.1.4 → 0.1.5

package/src/impl/{pouch → couch}/courseAPI.ts

@@ -1,15 +1,15 @@
 import pouch from './pouchdb-setup';
 import { pouchDBincludeCredentialsConfig } from '.';
-import { ENV } from '@/factory';
+import { ENV } from '@db/factory';
 // import { DataShape } from '../..base-course/Interfaces/DataShape';
 import { NameSpacer, ShapeDescriptor } from '@vue-skuilder/common';
 import { CourseConfig, DataShape } from '@vue-skuilder/common';
 import { CourseElo, blankCourseElo, toCourseElo } from '@vue-skuilder/common';
-import { CourseDB, createTag, updateCardElo } from './courseDB';
+import { CourseDB, createTag } from './courseDB';
 import { CardData, DisplayableData, DocType, Tag } from '../../core/types/types-legacy';
 import { prepareNote55 } from '@vue-skuilder/common';
-import { User } from './userDB';
-import { logger } from '@/util/logger';
+import { BaseUser } from '../common';
+import { logger } from '@db/util/logger';
 
 /**
  *
@@ -33,6 +33,8 @@ export async function addNote55(
 ): Promise<PouchDB.Core.Response> {
   const db = getCourseDB(courseID);
   const payload = prepareNote55(courseID, codeCourse, shape, data, author, tags, uploads);
+  // [ ] NAMESPACING: consider put( _id: "displayable_data-uuid")
+  //     consider also semantic hashing
   const result = await db.post<DisplayableData>(payload);
 
   const dataShapeId = NameSpacer.getDataShapeString({
@@ -139,6 +141,7 @@ async function addCard(
   elo: CourseElo,
   tags: string[]
 ): Promise<PouchDB.Core.Response> {
+  // [ ] NAMESPACING: consider put( _id: "card-uuid")
   const card = await getCourseDB(courseID).post<CardData>({
     course,
     id_displayable_data,
@@ -187,7 +190,16 @@ export async function addTagToCard(
   // In this case, should be converted to a server-request
   const prefixedTagID = getTagID(tagID);
   const courseDB = getCourseDB(courseID);
-  const courseApi = new CourseDB(courseID, async () => User.Dummy());
+  const courseApi = new CourseDB(courseID, async () => {
+    const dummySyncStrategy = {
+      setupRemoteDB: () => null as any,
+      startSync: () => {},
+      canCreateAccount: () => false,
+      canAuthenticate: () => false,
+      getCurrentUsername: async () => 'DummyUser',
+    };
+    return BaseUser.Dummy(dummySyncStrategy);
+  });
   try {
     logger.info(`Applying tag ${tagID} to card ${courseID + '-' + cardID}...`);
     const tag = await courseDB.get<Tag>(prefixedTagID);
@@ -220,6 +232,17 @@ export async function addTagToCard(
   }
 }
 
+async function updateCardElo(courseID: string, cardID: string, elo: CourseElo) {
+  if (elo) {
+    // checking against null, undefined, NaN
+    const cDB = getCourseDB(courseID);
+    const card = await cDB.get<CardData>(cardID);
+    logger.debug(`Replacing ${JSON.stringify(card.elo)} with ${JSON.stringify(elo)}`);
+    card.elo = elo;
+    return cDB.put(card); // race conditions - is it important? probably not (net-zero effect)
+  }
+}
+
 class AlreadyTaggedErr extends Error {
   constructor(message: string) {
     super(message);

package/src/impl/{pouch → couch}/courseDB.ts

@@ -1,5 +1,5 @@
-import { CourseDBInterface, CourseInfo, CoursesDBInterface, UserDBInterface } from '@/core';
-import { ScheduledCard } from '@/core/types/user';
+import { CourseDBInterface, CourseInfo, CoursesDBInterface, UserDBInterface } from '@db/core';
+import { ScheduledCard } from '@db/core/types/user';
 import {
   CourseConfig,
   CourseElo,
@@ -11,6 +11,7 @@ import {
 } from '@vue-skuilder/common';
 import _ from 'lodash';
 import { filterAllDocsByPrefix, getCourseDB, getCourseDoc, getCourseDocs } from '.';
+import UpdateQueue from './updateQueue';
 import {
   StudyContentSource,
   StudySessionItem,
@@ -21,11 +22,11 @@ import { CardData, DocType, SkuilderCourseData, Tag, TagStub } from '../../core/
 import { logger } from '../../util/logger';
 import { GET_CACHED } from './clientCache';
 import { addNote55, addTagToCard, getCredentialledCourseConfig, getTagID } from './courseAPI';
-import { DataLayerResult } from '@/core/types/db';
+import { DataLayerResult } from '@db/core/types/db';
 import { PouchError } from './types';
 import CourseLookup from './courseLookupDB';
-import { ContentNavigationStrategyData } from '@/core/types/contentNavigationStrategy';
-import { ContentNavigator, Navigators } from '@/core/navigators';
+import { ContentNavigationStrategyData } from '@db/core/types/contentNavigationStrategy';
+import { ContentNavigator, Navigators } from '@db/core/navigators';
 
 export class CoursesDB implements CoursesDBInterface {
   _courseIDs: string[] | undefined;
@@ -92,11 +93,13 @@ export class CourseDB implements StudyContentSource, CourseDBInterface {
   private db: PouchDB.Database;
   private id: string;
   private _getCurrentUser: () => Promise<UserDBInterface>;
+  private updateQueue: UpdateQueue;
 
   constructor(id: string, userLookup: () => Promise<UserDBInterface>) {
     this.id = id;
     this.db = getCourseDB(this.id);
     this._getCurrentUser = userLookup;
+    this.updateQueue = new UpdateQueue(this.db);
   }
 
   public getCourseID(): string {
@@ -305,11 +308,22 @@ above:\n${above.rows.map((r) => `\t${r.id}-${r.key}\n`)}`;
     }
   }
 
-  async updateCardElo(cardId: string, elo: CourseElo) {
-    const ret = await updateCardElo(this.id, cardId, elo);
-    if (ret) {
-      return ret;
-    } else {
+  async updateCardElo(cardId: string, elo: CourseElo): Promise<PouchDB.Core.Response> {
+    if (!elo) {
+      throw new Error(`Cannot update card elo with null or undefined value for card ID: ${cardId}`);
+    }
+
+    try {
+      const result = await this.updateQueue.update<
+        CardData & PouchDB.Core.GetMeta & PouchDB.Core.IdMeta
+      >(cardId, (card) => {
+        logger.debug(`Replacing ${JSON.stringify(card.elo)} with ${JSON.stringify(elo)}`);
+        card.elo = elo;
+        return card;
+      });
+      return { ok: true, id: cardId, rev: result._rev };
+    } catch (error) {
+      logger.error(`Failed to update card elo for card ID: ${cardId}`, error);
       throw new Error(`Failed to update card elo for card ID: ${cardId}`);
     }
   }

package/src/impl/{pouch → couch}/courseLookupDB.ts

@@ -1,5 +1,5 @@
 import pouch from './pouchdb-setup';
-import { ENV } from '@/factory';
+import { ENV } from '@db/factory';
 import { logger } from '../../util/logger';
 
 const courseLookupDBTitle = 'coursedb-lookup';

package/src/impl/{pouch → couch}/index.ts

@@ -1,14 +1,13 @@
-import { ENV } from '@/factory';
+import { ENV } from '@db/factory';
 import { DocType, GuestUsername, log, SkuilderCourseData } from '../../core/types/types-legacy';
 // import { getCurrentUser } from '../../stores/useAuthStore';
 import moment, { Moment } from 'moment';
-import { logger } from '@/util/logger';
+import { logger } from '@db/util/logger';
 
 import pouch from './pouchdb-setup';
 
-import { ScheduledCard } from '@/core/types/user';
+import { ScheduledCard } from '@db/core/types/user';
 import process from 'process';
-import { getUserDB } from './userDB';
 
 const isBrowser = typeof window !== 'undefined';
 
@@ -159,6 +158,28 @@ export async function getRandomCards(courseIDs: string[]) {
 export const REVIEW_PREFIX: string = 'card_review_';
 export const REVIEW_TIME_FORMAT: string = 'YYYY-MM-DD--kk:mm:ss-SSS';
 
+export function getCouchUserDB(username: string): PouchDB.Database {
+  const guestAccount: boolean = false;
+  // console.log(`Getting user db: ${username}`);
+
+  const hexName = hexEncode(username);
+  const dbName = `userdb-${hexName}`;
+  log(`Fetching user database: ${dbName} (${username})`);
+
+  // odd construction here the result of a bug in the
+  // interaction between pouch, pouch-auth.
+  // see: https://github.com/pouchdb-community/pouchdb-authentication/issues/239
+  const ret = new pouch(
+    ENV.COUCHDB_SERVER_PROTOCOL + '://' + ENV.COUCHDB_SERVER_URL + dbName,
+    pouchDBincludeCredentialsConfig
+  );
+  if (guestAccount) {
+    updateGuestAccountExpirationDate(ret);
+  }
+
+  return ret;
+}
+
 export function scheduleCardReview(review: {
   user: string;
   course_id: string;
@@ -169,7 +190,7 @@ export function scheduleCardReview(review: {
 }) {
   const now = moment.utc();
   logger.info(`Scheduling for review in: ${review.time.diff(now, 'h') / 24} days`);
-  void getUserDB(review.user).put<ScheduledCard>({
+  void getCouchUserDB(review.user).put<ScheduledCard>({
     _id: REVIEW_PREFIX + review.time.format(REVIEW_TIME_FORMAT),
     cardId: review.card_id,
     reviewTime: review.time,
@@ -180,20 +201,6 @@ export function scheduleCardReview(review: {
   });
 }
 
-export async function removeScheduledCardReview(user: string, reviewDocID: string) {
-  const db = getUserDB(user);
-  const reviewDoc = await db.get(reviewDocID);
-  db.remove(reviewDoc)
-    .then((res) => {
-      if (res.ok) {
-        log(`Removed Review Doc: ${reviewDocID}`);
-      }
-    })
-    .catch((err) => {
-      log(`Failed to remove Review Doc: ${reviewDocID},\n${JSON.stringify(err)}`);
-    });
-}
-
 export function filterAllDocsByPrefix<T>(
   db: PouchDB.Database,
   prefix: string,
@@ -232,4 +239,4 @@ export * from './adminDB';
 export * from './classroomDB';
 export * from './courseAPI';
 export * from './courseDB';
-export * from './userDB';
+export * from './CouchDBSyncStrategy';

package/src/impl/{pouch → couch}/updateQueue.ts

@@ -77,9 +77,13 @@ export default class UpdateQueue extends Loggable {
           }
           return doc;
         } catch (e) {
+          // Clean up queue state before re-throwing
           delete this.inprogressUpdates[id];
+          if (this.pendingUpdates[id]) {
+            delete this.pendingUpdates[id];
+          }
           logger.error(`Error on attemped update: ${JSON.stringify(e)}`);
-          throw e;
+          throw e; // Let caller handle (e.g., putCardRecord's 404 handling)
         }
       } else {
         throw new Error(`Empty Updates Queue Triggered`);

package/src/impl/{pouch → couch}/user-course-relDB.ts

@@ -1,4 +1,9 @@
-import { ScheduledCard, UserCourseSetting, UserCourseSettings, UsrCrsDataInterface } from '@/core';
+import {
+  ScheduledCard,
+  UserCourseSetting,
+  UserCourseSettings,
+  UsrCrsDataInterface,
+} from '@db/core';
 import moment, { Moment } from 'moment';
 import { getStartAndEndKeys, REVIEW_PREFIX, REVIEW_TIME_FORMAT } from '.';
 import { CourseDB } from './courseDB';

package/src/impl/static/NoOpSyncStrategy.ts

@@ -0,0 +1,70 @@
+// packages/db/src/impl/static/NoOpSyncStrategy.ts
+
+import { GuestUsername } from '../../core/types/types-legacy';
+import type { SyncStrategy } from '../common/SyncStrategy';
+import type { AccountCreationResult, AuthenticationResult } from '../common/types';
+import { getLocalUserDB } from '../common';
+
+/**
+ * Sync strategy for static deployments that provides no-op implementations
+ * for remote operations. Uses only local storage with no remote synchronization.
+ */
+export class NoOpSyncStrategy implements SyncStrategy {
+  private currentUsername: string = GuestUsername;
+
+  setupRemoteDB(username: string): PouchDB.Database {
+    // Return the same database instance as local - sync with self is a no-op
+    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
+  }
+
+  stopSync?(): void {
+    // No-op - no sync to stop in static mode
+  }
+
+  canCreateAccount(): boolean {
+    return false; // Account creation not supported in static mode
+  }
+
+  canAuthenticate(): boolean {
+    return false; // Remote authentication not supported in static mode
+  }
+
+  async createAccount(_username: string, _password: string): Promise<AccountCreationResult> {
+    throw new Error(
+      'Account creation not supported in static mode. Use local account switching instead.'
+    );
+  }
+
+  async authenticate(_username: string, _password: string): Promise<AuthenticationResult> {
+    throw new Error(
+      'Remote authentication not supported in static mode. Use local account switching instead.'
+    );
+  }
+
+  async logout(): Promise<AuthenticationResult> {
+    // In static mode, "logout" means switch back to guest user
+    this.currentUsername = GuestUsername;
+    return {
+      ok: true,
+    };
+  }
+
+  async getCurrentUsername(): Promise<string> {
+    // In static mode, always return guest username
+    // TODO: This will be enhanced with local account switching to support multiple local users
+    return this.currentUsername;
+  }
+
+  /**
+   * Set the current username (for local account switching)
+   * This method is specific to NoOpSyncStrategy and not part of the base interface
+   */
+  setCurrentUsername(username: string): void {
+    this.currentUsername = username;
+  }
+}

package/src/impl/static/StaticDataLayerProvider.ts

@@ -0,0 +1,89 @@
+// packages/db/src/impl/static/StaticDataLayerProvider.ts
+
+import {
+  AdminDBInterface,
+  ClassroomDBInterface,
+  CoursesDBInterface,
+  CourseDBInterface,
+  DataLayerProvider,
+  UserDBInterface,
+} from '../../core/interfaces';
+import { logger } from '../../util/logger';
+import { StaticCourseManifest } from '../../util/packer/types';
+import { StaticDataUnpacker } from './StaticDataUnpacker';
+import { StaticCourseDB } from './courseDB';
+import { StaticCoursesDB } from './coursesDB';
+import { BaseUser } from '../common';
+import { NoOpSyncStrategy } from './NoOpSyncStrategy';
+
+interface StaticDataLayerConfig {
+  staticContentPath: string;
+  localStoragePrefix?: string;
+  manifests: Record<string, StaticCourseManifest>; // courseId -> manifest
+}
+
+export class StaticDataLayerProvider implements DataLayerProvider {
+  private config: StaticDataLayerConfig;
+  private initialized: boolean = false;
+  private courseUnpackers: Map<string, StaticDataUnpacker> = new Map();
+
+  constructor(config: Partial<StaticDataLayerConfig>) {
+    this.config = {
+      staticContentPath: config.staticContentPath || '/static-courses',
+      localStoragePrefix: config.localStoragePrefix || 'skuilder-static',
+      manifests: config.manifests || {},
+    };
+  }
+
+  async initialize(): Promise<void> {
+    if (this.initialized) return;
+
+    logger.info('Initializing static data layer provider');
+
+    // 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);
+    }
+
+    this.initialized = true;
+  }
+
+  async teardown(): Promise<void> {
+    this.courseUnpackers.clear();
+    this.initialized = false;
+  }
+
+  getUserDB(): UserDBInterface {
+    const syncStrategy = new NoOpSyncStrategy();
+    // For now, use guest user - local account switching will be added later
+    return BaseUser.Dummy(syncStrategy);
+  }
+
+  getCourseDB(courseId: string): CourseDBInterface {
+    const unpacker = this.courseUnpackers.get(courseId);
+    if (!unpacker) {
+      throw new Error(`Course ${courseId} not found in static data`);
+    }
+    const manifest = this.config.manifests[courseId];
+    return new StaticCourseDB(courseId, unpacker, this.getUserDB(), manifest);
+  }
+
+  getCoursesDB(): CoursesDBInterface {
+    return new StaticCoursesDB(this.config.manifests);
+  }
+
+  async getClassroomDB(
+    _classId: string,
+    _type: 'student' | 'teacher'
+  ): Promise<ClassroomDBInterface> {
+    throw new Error('Classrooms not supported in static mode');
+  }
+
+  getAdminDB(): AdminDBInterface {
+    throw new Error('Admin functions not supported in static mode');
+  }
+}