@vue-skuilder/db 0.1.21 → 0.1.23

package/dist/index.mjs

@@ -5707,6 +5707,251 @@ var init_core = __esm({
 init_core();
 init_courseLookupDB();
 
+// src/courseConfigRegistration.ts
+init_logger();
+import { NameSpacer as NameSpacer2, toZodJSON } from "@vue-skuilder/common";
+function isDataShapeRegistered(dataShape, courseConfig) {
+  const namespacedName = NameSpacer2.getDataShapeString({
+    dataShape: dataShape.name,
+    course: dataShape.course
+  });
+  const existingDataShape = courseConfig.dataShapes.find((ds) => ds.name === namespacedName);
+  return existingDataShape !== void 0;
+}
+function isDataShapeSchemaAvailable(dataShape, courseConfig) {
+  const namespacedName = NameSpacer2.getDataShapeString({
+    dataShape: dataShape.name,
+    course: dataShape.course
+  });
+  const existingDataShape = courseConfig.dataShapes.find((ds) => ds.name === namespacedName);
+  return existingDataShape !== void 0 && existingDataShape.serializedZodSchema !== void 0;
+}
+function isQuestionTypeRegistered(question, courseConfig) {
+  const namespacedName = NameSpacer2.getQuestionString({
+    course: question.course,
+    questionType: question.name
+  });
+  return courseConfig.questionTypes.some((qt) => qt.name === namespacedName);
+}
+function processCustomQuestionsData(customQuestions) {
+  const processedDataShapes = [];
+  const processedQuestions = [];
+  const courseNames = customQuestions.courses.map((course) => course.name);
+  customQuestions.questionClasses.forEach((questionClass) => {
+    const courseName = courseNames.length > 0 ? courseNames[0] : customQuestions.meta.packageName;
+    if (questionClass.dataShapes && Array.isArray(questionClass.dataShapes)) {
+      questionClass.dataShapes.forEach((dataShape) => {
+        processedDataShapes.push({
+          name: dataShape.name,
+          course: courseName,
+          dataShape
+        });
+      });
+    }
+    processedQuestions.push({
+      name: questionClass.name,
+      course: courseName,
+      questionClass,
+      dataShapes: questionClass.dataShapes || [],
+      views: questionClass.views || []
+    });
+  });
+  return { dataShapes: processedDataShapes, questions: processedQuestions };
+}
+function registerDataShape(dataShape, courseConfig) {
+  const namespacedName = NameSpacer2.getDataShapeString({
+    dataShape: dataShape.name,
+    course: dataShape.course
+  });
+  let serializedZodSchema;
+  try {
+    serializedZodSchema = toZodJSON(dataShape.dataShape);
+  } catch (error) {
+    logger.warn(`Failed to generate schema for ${namespacedName}:`, error);
+    serializedZodSchema = void 0;
+  }
+  const existingIndex = courseConfig.dataShapes.findIndex((ds) => ds.name === namespacedName);
+  if (existingIndex !== -1) {
+    const existingDataShape = courseConfig.dataShapes[existingIndex];
+    if (existingDataShape.serializedZodSchema === serializedZodSchema) {
+      logger.info(
+        `DataShape '${dataShape.name}' from '${dataShape.course}' already registered with identical schema`
+      );
+      return false;
+    }
+    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`
+      );
+    }
+    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;
+}
+function registerQuestionType(question, courseConfig) {
+  if (isQuestionTypeRegistered(question, courseConfig)) {
+    logger.info(`QuestionType '${question.name}' from '${question.course}' already registered`);
+    return false;
+  }
+  const namespacedQuestionName = NameSpacer2.getQuestionString({
+    course: question.course,
+    questionType: question.name
+  });
+  const viewList = question.views.map((view) => {
+    if (view.name) {
+      return view.name;
+    } else {
+      return "unnamedComponent";
+    }
+  });
+  const dataShapeList = question.dataShapes.map(
+    (dataShape) => NameSpacer2.getDataShapeString({
+      course: question.course,
+      dataShape: dataShape.name
+    })
+  );
+  courseConfig.questionTypes.push({
+    name: namespacedQuestionName,
+    viewList,
+    dataShapeList
+  });
+  question.dataShapes.forEach((dataShape) => {
+    const namespacedDataShapeName = NameSpacer2.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;
+}
+async function registerSeedData(question, courseDB, username) {
+  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) => 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)}`
+      );
+    }
+  }
+}
+async function registerBlanksCard(BlanksCard, BlanksCardDataShapes, courseConfig, courseDB, username) {
+  try {
+    logger.info("Registering BlanksCard data shapes and question type...");
+    let registeredCount = 0;
+    const courseName = "default";
+    for (const dataShapeClass of BlanksCardDataShapes) {
+      const processedDataShape = {
+        name: dataShapeClass.name,
+        course: courseName,
+        dataShape: dataShapeClass
+      };
+      if (registerDataShape(processedDataShape, courseConfig)) {
+        registeredCount++;
+      }
+    }
+    const processedQuestion = {
+      name: BlanksCard.name,
+      course: courseName,
+      questionClass: {
+        name: BlanksCard.name,
+        dataShapes: BlanksCardDataShapes,
+        views: BlanksCard.views || []
+      },
+      dataShapes: BlanksCardDataShapes,
+      views: BlanksCard.views || []
+    };
+    if (registerQuestionType(processedQuestion, courseConfig)) {
+      registeredCount++;
+    }
+    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)}`);
+    }
+    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 };
+  }
+}
+async function registerCustomQuestionTypes(customQuestions, courseConfig, courseDB, username) {
+  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;
+    logger.info("Registering data shapes...");
+    for (const dataShape of dataShapes) {
+      if (registerDataShape(dataShape, courseConfig)) {
+        registeredCount++;
+      }
+    }
+    logger.info("Registering question types...");
+    for (const question of questions) {
+      if (registerQuestionType(question, courseConfig)) {
+        registeredCount++;
+      }
+    }
+    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)}`);
+    }
+    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 };
+  }
+}
+
 // src/study/services/SrsService.ts
 init_couch();
 import moment8 from "moment";
@@ -8156,13 +8401,22 @@ export {
   importParsedCards,
   initializeDataDirectory,
   initializeDataLayer,
+  isDataShapeRegistered,
+  isDataShapeSchemaAvailable,
   isFilter,
   isGenerator,
   isQuestionRecord,
+  isQuestionTypeRegistered,
   isReview,
   log,
   newInterval,
   parseCardHistoryID,
+  processCustomQuestionsData,
+  registerBlanksCard,
+  registerCustomQuestionTypes,
+  registerDataShape,
+  registerQuestionType,
+  registerSeedData,
   validateMigration,
   validateProcessorConfig,
   validateStaticCourse