@vue-skuilder/db 0.1.21 → 0.1.23

package/package.json

@@ -4,7 +4,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "Database layer for vue-skuilder",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "@nilock2/pouchdb-authentication": "^1.0.2",
-    "@vue-skuilder/common": "0.1.21",
+    "@vue-skuilder/common": "0.1.23",
     "cross-fetch": "^4.1.0",
     "moment": "^2.29.4",
     "pouchdb": "^9.0.0",
@@ -62,5 +62,5 @@
     "vite": "^7.0.0",
     "vitest": "^4.0.15"
   },
-  "stableVersion": "0.1.21"
+  "stableVersion": "0.1.23"
 }

package/src/courseConfigRegistration.ts

@@ -0,0 +1,439 @@
+import { CourseConfig, DataShape, NameSpacer, toZodJSON } from '@vue-skuilder/common';
+import { CourseDBInterface } from './core/interfaces/courseDB.js';
+import { logger } from './util/logger.js';
+
+/**
+ * Interface for custom questions data structure returned by allCustomQuestions()
+ */
+export interface CustomQuestionsData {
+  courses: { name: string }[]; // Course instances with question instances
+  questionClasses: {
+    name: string;
+    dataShapes?: DataShape[];
+    views?: { name?: string }[];
+    seedData?: unknown[];
+  }[]; // Question class constructors
+  dataShapes: DataShape[]; // DataShape definitions for studio-ui
+  views: { name?: string }[]; // Vue components for rendering
+  meta: {
+    questionCount: number;
+    dataShapeCount: number;
+    viewCount: number;
+    courseCount: number;
+    packageName: string;
+    sourceDirectory: string;
+  };
+}
+
+/**
+ * Interface for processed question data for registration
+ */
+export interface ProcessedQuestionData {
+  name: string;
+  course: string;
+  questionClass: {
+    name: string;
+    dataShapes?: DataShape[];
+    views?: { name?: string }[];
+    seedData?: unknown[];
+  };
+  dataShapes: DataShape[];
+  views: { name?: string }[];
+}
+
+/**
+ * Interface for processed data shape for registration
+ */
+export interface ProcessedDataShape {
+  name: string;
+  course: string;
+  dataShape: DataShape;
+}
+
+/**
+ * Check if a data shape is already registered in the course config with valid schema
+ */
+export function isDataShapeRegistered(
+  dataShape: ProcessedDataShape,
+  courseConfig: CourseConfig
+): boolean {
+  const namespacedName = NameSpacer.getDataShapeString({
+    dataShape: dataShape.name,
+    course: dataShape.course,
+  });
+
+  const existingDataShape = courseConfig.dataShapes.find((ds) => ds.name === namespacedName);
+
+  // existence sufficient to be considered "registered"
+  return existingDataShape !== undefined;
+}
+
+export function isDataShapeSchemaAvailable(
+  dataShape: ProcessedDataShape,
+  courseConfig: CourseConfig
+): boolean {
+  const namespacedName = NameSpacer.getDataShapeString({
+    dataShape: dataShape.name,
+    course: dataShape.course,
+  });
+
+  const existingDataShape = courseConfig.dataShapes.find((ds) => ds.name === namespacedName);
+
+  return existingDataShape !== undefined && existingDataShape.serializedZodSchema !== undefined;
+}
+
+/**
+ * Check if a question type is already registered in the course config
+ */
+export function isQuestionTypeRegistered(
+  question: ProcessedQuestionData,
+  courseConfig: CourseConfig
+): boolean {
+  const namespacedName = NameSpacer.getQuestionString({
+    course: question.course,
+    questionType: question.name,
+  });
+
+  return courseConfig.questionTypes.some((qt) => qt.name === namespacedName);
+}
+
+/**
+ * Process custom questions data into registration-ready format
+ */
+export function processCustomQuestionsData(customQuestions: CustomQuestionsData): {
+  dataShapes: ProcessedDataShape[];
+  questions: ProcessedQuestionData[];
+} {
+  const processedDataShapes: ProcessedDataShape[] = [];
+  const processedQuestions: ProcessedQuestionData[] = [];
+
+  // Extract course names from the custom questions
+  const courseNames = customQuestions.courses.map((course) => course.name);
+
+  // Process each question class
+  customQuestions.questionClasses.forEach((questionClass) => {
+    // Determine the course name (use first course or default to meta.packageName)
+    const courseName = courseNames.length > 0 ? courseNames[0] : customQuestions.meta.packageName;
+
+    // Process data shapes from this question class (static property)
+    if (questionClass.dataShapes && Array.isArray(questionClass.dataShapes)) {
+      questionClass.dataShapes.forEach((dataShape) => {
+        processedDataShapes.push({
+          name: dataShape.name,
+          course: courseName,
+          dataShape: dataShape,
+        });
+      });
+    }
+
+    // Process the question itself
+    processedQuestions.push({
+      name: questionClass.name,
+      course: courseName,
+      questionClass: questionClass,
+      dataShapes: questionClass.dataShapes || [],
+      views: questionClass.views || [],
+    });
+  });
+
+  return { dataShapes: processedDataShapes, questions: processedQuestions };
+}
+
+/**
+ * Register a data shape in the course config
+ */
+export function registerDataShape(
+  dataShape: ProcessedDataShape,
+  courseConfig: CourseConfig
+): boolean {
+  const namespacedName = NameSpacer.getDataShapeString({
+    dataShape: dataShape.name,
+    course: dataShape.course,
+  });
+
+  // Generate JSON Schema for the DataShape
+  let serializedZodSchema: string | undefined;
+  try {
+    serializedZodSchema = toZodJSON(dataShape.dataShape);
+  } catch (error) {
+    logger.warn(`Failed to generate schema for ${namespacedName}:`, error);
+    serializedZodSchema = undefined;
+  }
+
+  // Check if DataShape already exists
+  const existingIndex = courseConfig.dataShapes.findIndex((ds) => ds.name === namespacedName);
+
+  if (existingIndex !== -1) {
+    const existingDataShape = courseConfig.dataShapes[existingIndex];
+
+    // If existing schema matches new schema, no update needed
+    if (existingDataShape.serializedZodSchema === serializedZodSchema) {
+      logger.info(
+        `DataShape '${dataShape.name}' from '${dataShape.course}' already registered with identical schema`
+      );
+      return false;
+    }
+
+    // Schema has changed or was missing - update it
+    if (existingDataShape.serializedZodSchema) {
+      logger.info(
+        `DataShape '${dataShape.name}' from '${dataShape.course}' schema has changed, updating...`
+      );
+    } else {
+      logger.info(
+        `DataShape '${dataShape.name}' from '${dataShape.course}' already registered, but with no schema. Adding schema to existing entry`
+      );
+    }
+
+    // Update the existing entry
+    courseConfig.dataShapes[existingIndex] = {
+      name: namespacedName,
+      questionTypes: existingDataShape.questionTypes, // Preserve existing question type associations
+      serializedZodSchema,
+    };
+
+    logger.info(`Updated DataShape: ${namespacedName}`);
+    return true;
+  }
+
+  courseConfig.dataShapes.push({
+    name: namespacedName,
+    questionTypes: [],
+    serializedZodSchema,
+  });
+
+  logger.info(`Registered DataShape: ${namespacedName}`);
+  return true;
+}
+
+/**
+ * Register a question type in the course config
+ */
+export function registerQuestionType(
+  question: ProcessedQuestionData,
+  courseConfig: CourseConfig
+): boolean {
+  if (isQuestionTypeRegistered(question, courseConfig)) {
+    logger.info(`QuestionType '${question.name}' from '${question.course}' already registered`);
+    return false;
+  }
+
+  const namespacedQuestionName = NameSpacer.getQuestionString({
+    course: question.course,
+    questionType: question.name,
+  });
+
+  // Build view list
+  const viewList = question.views.map((view) => {
+    if (view.name) {
+      return view.name;
+    } else {
+      return 'unnamedComponent';
+    }
+  });
+
+  // Build data shape list
+  const dataShapeList = question.dataShapes.map((dataShape) =>
+    NameSpacer.getDataShapeString({
+      course: question.course,
+      dataShape: dataShape.name,
+    })
+  );
+
+  // Add question type to course config
+  courseConfig.questionTypes.push({
+    name: namespacedQuestionName,
+    viewList: viewList,
+    dataShapeList: dataShapeList,
+  });
+
+  // Cross-reference: Add this question type to its data shapes
+  question.dataShapes.forEach((dataShape) => {
+    const namespacedDataShapeName = NameSpacer.getDataShapeString({
+      course: question.course,
+      dataShape: dataShape.name,
+    });
+
+    for (const ds of courseConfig.dataShapes) {
+      if (ds.name === namespacedDataShapeName) {
+        ds.questionTypes.push(namespacedQuestionName);
+      }
+    }
+  });
+
+  logger.info(`Registered QuestionType: ${namespacedQuestionName}`);
+  return true;
+}
+
+/**
+ * Register seed data for a question type
+ *
+ * @param question - The processed question data
+ * @param courseDB - The course database interface
+ * @param username - The username to attribute seed data to
+ */
+export async function registerSeedData(
+  question: ProcessedQuestionData,
+  courseDB: CourseDBInterface,
+  username: string
+): Promise<void> {
+  if (question.questionClass.seedData && Array.isArray(question.questionClass.seedData)) {
+    logger.info(`Registering seed data for question: ${question.name}`);
+
+    try {
+      const seedDataPromises = question.questionClass.seedData
+        .filter(() => question.dataShapes.length > 0)
+        .map((seedDataItem: unknown) =>
+          courseDB.addNote(
+            question.course,
+            question.dataShapes[0],
+            seedDataItem,
+            username,
+            []
+          )
+        );
+
+      await Promise.all(seedDataPromises);
+      logger.info(`Seed data registered for question: ${question.name}`);
+    } catch (error) {
+      logger.warn(
+        `Failed to register seed data for question '${question.name}': ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}
+
+/**
+ * Register BlanksCard (markdown fillIn) question type specifically
+ */
+export async function registerBlanksCard(
+  BlanksCard: { name: string; views?: { name?: string }[] },
+  BlanksCardDataShapes: DataShape[],
+  courseConfig: CourseConfig,
+  courseDB: CourseDBInterface,
+  username?: string
+): Promise<{ success: boolean; errorMessage?: string }> {
+  try {
+    logger.info('Registering BlanksCard data shapes and question type...');
+
+    let registeredCount = 0;
+    const courseName = 'default'; // BlanksCard comes from the default course
+
+    // Register BlanksCard data shapes
+    for (const dataShapeClass of BlanksCardDataShapes) {
+      const processedDataShape: ProcessedDataShape = {
+        name: dataShapeClass.name,
+        course: courseName,
+        dataShape: dataShapeClass,
+      };
+
+      if (registerDataShape(processedDataShape, courseConfig)) {
+        registeredCount++;
+      }
+    }
+
+    // Register BlanksCard question type
+    const processedQuestion: ProcessedQuestionData = {
+      name: BlanksCard.name,
+      course: courseName,
+      questionClass: {
+        name: BlanksCard.name,
+        dataShapes: BlanksCardDataShapes,
+        views: BlanksCard.views || [],
+      },
+      dataShapes: BlanksCardDataShapes,
+      views: BlanksCard.views || [],
+    };
+
+    if (registerQuestionType(processedQuestion, courseConfig)) {
+      registeredCount++;
+    }
+
+    // Update the course config in the database
+    logger.info('Updating course configuration with BlanksCard...');
+    const updateResult = await courseDB.updateCourseConfig(courseConfig);
+
+    if (!updateResult.ok) {
+      throw new Error(`Failed to update course config: ${JSON.stringify(updateResult)}`);
+    }
+
+    // Register seed data if BlanksCard has any and username provided
+    if (username) {
+      await registerSeedData(processedQuestion, courseDB, username);
+    }
+
+    logger.info(`BlanksCard registration complete: ${registeredCount} items registered`);
+
+    return { success: true };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`BlanksCard registration failed: ${errorMessage}`);
+    return { success: false, errorMessage };
+  }
+}
+
+/**
+ * Main function to register all custom question types and data shapes
+ *
+ * @param customQuestions - The custom questions data from allCustomQuestions()
+ * @param courseConfig - The course configuration object
+ * @param courseDB - The course database interface
+ * @param username - The username to attribute seed data to
+ */
+export async function registerCustomQuestionTypes(
+  customQuestions: CustomQuestionsData,
+  courseConfig: CourseConfig,
+  courseDB: CourseDBInterface,
+  username?: string
+): Promise<{ success: boolean; registeredCount: number; errorMessage?: string }> {
+  try {
+    logger.info('Beginning custom question registration');
+    logger.info(`Processing ${customQuestions.questionClasses.length} question classes`);
+
+    const { dataShapes, questions } = processCustomQuestionsData(customQuestions);
+
+    logger.info(`Found ${dataShapes.length} data shapes and ${questions.length} questions`);
+
+    let registeredCount = 0;
+
+    // First, register all data shapes
+    logger.info('Registering data shapes...');
+    for (const dataShape of dataShapes) {
+      if (registerDataShape(dataShape, courseConfig)) {
+        registeredCount++;
+      }
+    }
+
+    // Then, register all question types
+    logger.info('Registering question types...');
+    for (const question of questions) {
+      if (registerQuestionType(question, courseConfig)) {
+        registeredCount++;
+      }
+    }
+
+    // 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)}`);
+    }
+
+    // Register seed data for questions that have it (if username provided)
+    if (username) {
+      logger.info('Registering seed data...');
+      for (const question of questions) {
+        await registerSeedData(question, courseDB, username);
+      }
+    }
+
+    logger.info(`Custom question registration complete: ${registeredCount} items registered`);
+
+    return { success: true, registeredCount };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`Custom question registration failed: ${errorMessage}`);
+    return { success: false, registeredCount: 0, errorMessage };
+  }
+}

package/src/index.ts

@@ -2,6 +2,8 @@ export * from './core';
 
 export { default as CourseLookup } from './impl/couch/courseLookupDB';
 
+export * from './courseConfigRegistration';
+
 export * from './study';
 
 export * from './util';