@contractspec/module.learning-journey 1.57.0 → 1.59.0

package/dist/node/entities/quiz.js

@@ -0,0 +1,304 @@
+// src/entities/quiz.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var QuestionTypeEnum = defineEntityEnum({
+  name: "QuestionType",
+  values: [
+    "MULTIPLE_CHOICE",
+    "TRUE_FALSE",
+    "FILL_BLANK",
+    "MATCHING",
+    "SHORT_ANSWER",
+    "CODE"
+  ],
+  schema: "lssm_learning",
+  description: "Type of quiz question."
+});
+var QuizStatusEnum = defineEntityEnum({
+  name: "QuizStatus",
+  values: ["DRAFT", "PUBLISHED", "ARCHIVED"],
+  schema: "lssm_learning",
+  description: "Publication status of a quiz."
+});
+var AttemptStatusEnum = defineEntityEnum({
+  name: "AttemptStatus",
+  values: ["IN_PROGRESS", "COMPLETED", "TIMED_OUT", "ABANDONED"],
+  schema: "lssm_learning",
+  description: "Status of a quiz attempt."
+});
+var QuizEntity = defineEntity({
+  name: "Quiz",
+  description: "A quiz assessment.",
+  schema: "lssm_learning",
+  map: "quiz",
+  fields: {
+    id: field.id({ description: "Unique quiz identifier" }),
+    lessonId: field.foreignKey({
+      isOptional: true,
+      description: "Associated lesson"
+    }),
+    title: field.string({ description: "Quiz title" }),
+    description: field.string({
+      isOptional: true,
+      description: "Quiz description"
+    }),
+    instructions: field.string({
+      isOptional: true,
+      description: "Quiz instructions"
+    }),
+    passingScore: field.int({
+      default: 70,
+      description: "Passing score percentage"
+    }),
+    timeLimit: field.int({
+      isOptional: true,
+      description: "Time limit in seconds"
+    }),
+    maxAttempts: field.int({
+      isOptional: true,
+      description: "Maximum attempts allowed"
+    }),
+    shuffleQuestions: field.boolean({
+      default: false,
+      description: "Shuffle question order"
+    }),
+    shuffleOptions: field.boolean({
+      default: false,
+      description: "Shuffle answer options"
+    }),
+    showCorrectAnswers: field.boolean({
+      default: true,
+      description: "Show correct answers after"
+    }),
+    showExplanations: field.boolean({
+      default: true,
+      description: "Show explanations after"
+    }),
+    status: field.enum("QuizStatus", {
+      default: "DRAFT",
+      description: "Publication status"
+    }),
+    totalPoints: field.int({
+      default: 0,
+      description: "Total points available"
+    }),
+    xpReward: field.int({ default: 20, description: "XP for passing" }),
+    orgId: field.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    lesson: field.belongsTo("Lesson", ["lessonId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    questions: field.hasMany("Question"),
+    attempts: field.hasMany("QuizAttempt")
+  },
+  indexes: [index.on(["lessonId"]), index.on(["status"]), index.on(["orgId"])],
+  enums: [QuizStatusEnum]
+});
+var QuestionEntity = defineEntity({
+  name: "Question",
+  description: "A quiz question.",
+  schema: "lssm_learning",
+  map: "question",
+  fields: {
+    id: field.id({ description: "Unique question identifier" }),
+    quizId: field.foreignKey({ description: "Parent quiz" }),
+    type: field.enum("QuestionType", { description: "Question type" }),
+    content: field.string({ description: "Question text" }),
+    mediaUrl: field.string({ isOptional: true, description: "Question media" }),
+    points: field.int({ default: 1, description: "Points for correct answer" }),
+    codeLanguage: field.string({
+      isOptional: true,
+      description: "Programming language"
+    }),
+    codeTemplate: field.string({
+      isOptional: true,
+      description: "Starter code template"
+    }),
+    testCases: field.json({
+      isOptional: true,
+      description: "Test cases for code validation"
+    }),
+    explanation: field.string({
+      isOptional: true,
+      description: "Explanation of correct answer"
+    }),
+    hint: field.string({
+      isOptional: true,
+      description: "Hint for the question"
+    }),
+    order: field.int({ default: 0, description: "Display order" }),
+    skillId: field.string({
+      isOptional: true,
+      description: "Associated skill"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    quiz: field.belongsTo("Quiz", ["quizId"], ["id"], { onDelete: "Cascade" }),
+    options: field.hasMany("QuestionOption")
+  },
+  indexes: [
+    index.on(["quizId", "order"]),
+    index.on(["type"]),
+    index.on(["skillId"])
+  ],
+  enums: [QuestionTypeEnum]
+});
+var QuestionOptionEntity = defineEntity({
+  name: "QuestionOption",
+  description: "An answer option for a question.",
+  schema: "lssm_learning",
+  map: "question_option",
+  fields: {
+    id: field.id({ description: "Unique option identifier" }),
+    questionId: field.foreignKey({ description: "Parent question" }),
+    content: field.string({ description: "Option text" }),
+    matchContent: field.string({
+      isOptional: true,
+      description: "Match pair content"
+    }),
+    isCorrect: field.boolean({
+      default: false,
+      description: "Whether option is correct"
+    }),
+    feedback: field.string({
+      isOptional: true,
+      description: "Feedback when selected"
+    }),
+    order: field.int({ default: 0, description: "Display order" }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    question: field.belongsTo("Question", ["questionId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [index.on(["questionId", "order"])]
+});
+var QuizAttemptEntity = defineEntity({
+  name: "QuizAttempt",
+  description: "A learner quiz attempt.",
+  schema: "lssm_learning",
+  map: "quiz_attempt",
+  fields: {
+    id: field.id({ description: "Unique attempt identifier" }),
+    learnerId: field.foreignKey({ description: "Learner" }),
+    quizId: field.foreignKey({ description: "Quiz" }),
+    status: field.enum("AttemptStatus", {
+      default: "IN_PROGRESS",
+      description: "Attempt status"
+    }),
+    score: field.int({ isOptional: true, description: "Score achieved" }),
+    percentageScore: field.int({
+      isOptional: true,
+      description: "Percentage score"
+    }),
+    passed: field.boolean({ isOptional: true, description: "Whether passed" }),
+    totalQuestions: field.int({ default: 0, description: "Total questions" }),
+    answeredQuestions: field.int({
+      default: 0,
+      description: "Questions answered"
+    }),
+    correctAnswers: field.int({ default: 0, description: "Correct answers" }),
+    answers: field.json({ isOptional: true, description: "Submitted answers" }),
+    xpEarned: field.int({ default: 0, description: "XP earned" }),
+    timeSpent: field.int({ default: 0, description: "Time spent in seconds" }),
+    startedAt: field.dateTime({ description: "When started" }),
+    completedAt: field.dateTime({
+      isOptional: true,
+      description: "When completed"
+    }),
+    attemptNumber: field.int({
+      default: 1,
+      description: "Which attempt this is"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    learner: field.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    quiz: field.belongsTo("Quiz", ["quizId"], ["id"], { onDelete: "Cascade" })
+  },
+  indexes: [
+    index.on(["learnerId", "quizId"]),
+    index.on(["learnerId", "status"]),
+    index.on(["quizId", "status"])
+  ],
+  enums: [AttemptStatusEnum]
+});
+var SkillAssessmentEntity = defineEntity({
+  name: "SkillAssessment",
+  description: "Assessment of a skill based on quiz performance.",
+  schema: "lssm_learning",
+  map: "skill_assessment",
+  fields: {
+    id: field.id({ description: "Unique assessment identifier" }),
+    learnerId: field.foreignKey({ description: "Learner" }),
+    skillId: field.string({ description: "Skill identifier" }),
+    skillName: field.string({ description: "Skill name" }),
+    level: field.int({ default: 1, description: "Proficiency level (1-5)" }),
+    score: field.int({ default: 0, description: "Assessment score (0-100)" }),
+    confidence: field.decimal({
+      default: 0.5,
+      description: "Confidence in assessment"
+    }),
+    questionsAnswered: field.int({
+      default: 0,
+      description: "Total questions answered"
+    }),
+    questionsCorrect: field.int({ default: 0, description: "Total correct" }),
+    assessedAt: field.dateTime({ description: "Last assessment time" }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    learner: field.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index.unique(["learnerId", "skillId"], { name: "skill_assessment_unique" }),
+    index.on(["learnerId", "level"]),
+    index.on(["skillId"])
+  ]
+});
+var quizEntities = [
+  QuizEntity,
+  QuestionEntity,
+  QuestionOptionEntity,
+  QuizAttemptEntity,
+  SkillAssessmentEntity
+];
+var quizEnums = [QuestionTypeEnum, QuizStatusEnum, AttemptStatusEnum];
+export {
+  quizEnums,
+  quizEntities,
+  SkillAssessmentEntity,
+  QuizStatusEnum,
+  QuizEntity,
+  QuizAttemptEntity,
+  QuestionTypeEnum,
+  QuestionOptionEntity,
+  QuestionEntity,
+  AttemptStatusEnum
+};