@vue-skuilder/db 0.1.23 → 0.1.25

package/src/courseConfigRegistration.ts

@@ -265,6 +265,113 @@ export function registerQuestionType(
   return true;
 }
 
+/**
+ * Remove a data shape from the course config
+ * @returns true if the data shape was removed, false if it wasn't found
+ */
+export function removeDataShape(
+  dataShapeName: string,
+  courseConfig: CourseConfig
+): boolean {
+  const index = courseConfig.dataShapes.findIndex((ds) => ds.name === dataShapeName);
+
+  if (index === -1) {
+    logger.info(`DataShape '${dataShapeName}' not found in course config`);
+    return false;
+  }
+
+  // Remove the data shape
+  courseConfig.dataShapes.splice(index, 1);
+
+  // Also remove references from any question types
+  courseConfig.questionTypes.forEach((qt) => {
+    const dsIndex = qt.dataShapeList.indexOf(dataShapeName);
+    if (dsIndex !== -1) {
+      qt.dataShapeList.splice(dsIndex, 1);
+    }
+  });
+
+  logger.info(`Removed DataShape: ${dataShapeName}`);
+  return true;
+}
+
+/**
+ * Remove a question type from the course config
+ * @returns true if the question type was removed, false if it wasn't found
+ */
+export function removeQuestionType(
+  questionTypeName: string,
+  courseConfig: CourseConfig
+): boolean {
+  const index = courseConfig.questionTypes.findIndex((qt) => qt.name === questionTypeName);
+
+  if (index === -1) {
+    logger.info(`QuestionType '${questionTypeName}' not found in course config`);
+    return false;
+  }
+
+  // Remove the question type
+  courseConfig.questionTypes.splice(index, 1);
+
+  // Also remove references from data shapes
+  courseConfig.dataShapes.forEach((ds) => {
+    const qtIndex = ds.questionTypes.indexOf(questionTypeName);
+    if (qtIndex !== -1) {
+      ds.questionTypes.splice(qtIndex, 1);
+    }
+  });
+
+  logger.info(`Removed QuestionType: ${questionTypeName}`);
+  return true;
+}
+
+/**
+ * Remove data shapes and question types from course config and persist to database
+ */
+export async function removeCustomQuestionTypes(
+  dataShapeNames: string[],
+  questionTypeNames: string[],
+  courseConfig: CourseConfig,
+  courseDB: CourseDBInterface
+): Promise<{ success: boolean; removedCount: number; errorMessage?: string }> {
+  try {
+    logger.info('Beginning custom question removal');
+    logger.info(`Removing ${dataShapeNames.length} data shapes and ${questionTypeNames.length} question types`);
+
+    let removedCount = 0;
+
+    // Remove question types first (they reference data shapes)
+    for (const qtName of questionTypeNames) {
+      if (removeQuestionType(qtName, courseConfig)) {
+        removedCount++;
+      }
+    }
+
+    // Then remove data shapes
+    for (const dsName of dataShapeNames) {
+      if (removeDataShape(dsName, courseConfig)) {
+        removedCount++;
+      }
+    }
+
+    // Update the course config in the database
+    logger.info('Updating course configuration...');
+    const updateResult = await courseDB.updateCourseConfig(courseConfig);
+
+    if (!updateResult.ok) {
+      throw new Error(`Failed to update course config: ${JSON.stringify(updateResult)}`);
+    }
+
+    logger.info(`Custom question removal complete: ${removedCount} items removed`);
+
+    return { success: true, removedCount };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`Custom question removal failed: ${errorMessage}`);
+    return { success: false, removedCount: 0, errorMessage };
+  }
+}
+
 /**
  * Register seed data for a question type
  *

package/src/factory.ts

@@ -4,6 +4,7 @@ import { DataLayerProvider } from './core/interfaces';
 import { BaseUser } from './impl/common';
 import { logger } from './util/logger';
 import { StaticCourseManifest } from './util/packer/types';
+import { initializeNavigatorRegistry } from './core/navigators';
 
 const NOT_SET = 'NOT_SET' as const;
 
@@ -50,6 +51,11 @@ export async function initializeDataLayer(config: DataLayerConfig): Promise<Data
     logger.warn('Data layer already initialized. Returning existing instance.');
     return dataLayerInstance;
   }
+
+  // Initialize the navigator registry before creating the data layer.
+  // This ensures all built-in navigators are available for pipeline assembly.
+  await initializeNavigatorRegistry();
+
   if (config.options.localStoragePrefix) {
     ENV.LOCAL_STORAGE_PREFIX = config.options.localStoragePrefix;
   }

package/src/impl/common/BaseUserDB.ts

@@ -20,6 +20,7 @@ import {
 } from '@db/core/types/user';
 import { DocumentUpdater } from '@db/study';
 import { CardHistory, CardRecord } from '../../core/types/types-legacy';
+import { UserOutcomeRecord } from '../../core/types/userOutcome';
 import type { SyncStrategy } from './SyncStrategy';
 import {
   filterAllDocsByPrefix,
@@ -1088,6 +1089,21 @@ Currently logged-in as ${this._username}.`
     await this.localDB.put(doc);
   }
 
+  public async putUserOutcome(record: UserOutcomeRecord): Promise<void> {
+    try {
+      await this.localDB.put(record);
+    } catch (err: any) {
+      if (err.status === 409) {
+        // Overwrite if exists
+        const existing = await this.localDB.get(record._id);
+        (record as any)._rev = existing._rev;
+        await this.localDB.put(record);
+      } else {
+        throw err;
+      }
+    }
+  }
+
   public async deleteStrategyState(courseId: string, strategyKey: string): Promise<void> {
     const docId = buildStrategyStateId(courseId, strategyKey);
     try {

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

@@ -52,6 +52,18 @@ export class UsrCrsData implements UsrCrsDataInterface {
     }
   }
 
+  public async getStrategyState<T>(strategyKey: string): Promise<T | null> {
+    return this.user.getStrategyState<T>(this._courseId, strategyKey);
+  }
+
+  public async putStrategyState<T>(strategyKey: string, data: T): Promise<void> {
+    return this.user.putStrategyState<T>(this._courseId, strategyKey, data);
+  }
+
+  public async deleteStrategyState(strategyKey: string): Promise<void> {
+    return this.user.deleteStrategyState(this._courseId, strategyKey);
+  }
+
   private async getReviewstoDate(targetDate: Moment) {
     // Use the interface method instead of direct database access
     const allReviews = await this.user.getPendingReviews(this._courseId);