@contractspec/module.learning-journey 1.57.0 → 1.59.0

package/dist/browser/entities/course.js

@@ -0,0 +1,276 @@
+// src/entities/course.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var CourseDifficultyEnum = defineEntityEnum({
+  name: "CourseDifficulty",
+  values: ["BEGINNER", "INTERMEDIATE", "ADVANCED", "EXPERT"],
+  schema: "lssm_learning",
+  description: "Difficulty level of a course."
+});
+var CourseStatusEnum = defineEntityEnum({
+  name: "CourseStatus",
+  values: ["DRAFT", "PUBLISHED", "ARCHIVED"],
+  schema: "lssm_learning",
+  description: "Publication status of a course."
+});
+var LessonTypeEnum = defineEntityEnum({
+  name: "LessonType",
+  values: [
+    "CONTENT",
+    "VIDEO",
+    "INTERACTIVE",
+    "QUIZ",
+    "PRACTICE",
+    "PROJECT"
+  ],
+  schema: "lssm_learning",
+  description: "Type of lesson content."
+});
+var ContentTypeEnum = defineEntityEnum({
+  name: "ContentType",
+  values: ["MARKDOWN", "VIDEO", "AUDIO", "EMBED", "SCORM", "CUSTOM"],
+  schema: "lssm_learning",
+  description: "Type of lesson content format."
+});
+var CourseEntity = defineEntity({
+  name: "Course",
+  description: "A structured learning course.",
+  schema: "lssm_learning",
+  map: "course",
+  fields: {
+    id: field.id({ description: "Unique course identifier" }),
+    title: field.string({ description: "Course title" }),
+    slug: field.string({ isUnique: true, description: "URL-friendly slug" }),
+    description: field.string({
+      isOptional: true,
+      description: "Course description"
+    }),
+    summary: field.string({ isOptional: true, description: "Short summary" }),
+    difficulty: field.enum("CourseDifficulty", {
+      default: "BEGINNER",
+      description: "Difficulty level"
+    }),
+    category: field.string({
+      isOptional: true,
+      description: "Course category"
+    }),
+    tags: field.json({ isOptional: true, description: "Tags for discovery" }),
+    prerequisites: field.json({
+      isOptional: true,
+      description: "Required course IDs"
+    }),
+    requiredSkills: field.json({
+      isOptional: true,
+      description: "Required skill levels"
+    }),
+    estimatedDuration: field.int({
+      isOptional: true,
+      description: "Estimated duration in minutes"
+    }),
+    thumbnailUrl: field.string({
+      isOptional: true,
+      description: "Thumbnail image URL"
+    }),
+    coverImageUrl: field.string({
+      isOptional: true,
+      description: "Cover image URL"
+    }),
+    promoVideoUrl: field.string({
+      isOptional: true,
+      description: "Promo video URL"
+    }),
+    status: field.enum("CourseStatus", {
+      default: "DRAFT",
+      description: "Publication status"
+    }),
+    publishedAt: field.dateTime({
+      isOptional: true,
+      description: "When published"
+    }),
+    authorId: field.string({ description: "Author user ID" }),
+    orgId: field.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    isPublic: field.boolean({
+      default: false,
+      description: "Whether course is publicly accessible"
+    }),
+    isFeatured: field.boolean({
+      default: false,
+      description: "Whether course is featured"
+    }),
+    certificateEnabled: field.boolean({
+      default: false,
+      description: "Award certificate on completion"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    modules: field.hasMany("CourseModule"),
+    enrollments: field.hasMany("Enrollment")
+  },
+  indexes: [
+    index.on(["orgId", "status"]),
+    index.on(["category"]),
+    index.on(["difficulty"]),
+    index.on(["authorId"])
+  ],
+  enums: [CourseDifficultyEnum, CourseStatusEnum]
+});
+var CourseModuleEntity = defineEntity({
+  name: "CourseModule",
+  description: "A module (section) within a course.",
+  schema: "lssm_learning",
+  map: "course_module",
+  fields: {
+    id: field.id({ description: "Unique module identifier" }),
+    courseId: field.foreignKey({ description: "Parent course" }),
+    title: field.string({ description: "Module title" }),
+    description: field.string({
+      isOptional: true,
+      description: "Module description"
+    }),
+    order: field.int({ default: 0, description: "Display order" }),
+    unlockCondition: field.json({
+      isOptional: true,
+      description: "Conditions to unlock module"
+    }),
+    prerequisiteModuleIds: field.json({
+      isOptional: true,
+      description: "Required modules to complete first"
+    }),
+    estimatedDuration: field.int({
+      isOptional: true,
+      description: "Estimated duration in minutes"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    course: field.belongsTo("Course", ["courseId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    lessons: field.hasMany("Lesson"),
+    completions: field.hasMany("ModuleCompletion")
+  },
+  indexes: [index.on(["courseId", "order"])]
+});
+var LessonEntity = defineEntity({
+  name: "Lesson",
+  description: "An individual lesson within a module.",
+  schema: "lssm_learning",
+  map: "lesson",
+  fields: {
+    id: field.id({ description: "Unique lesson identifier" }),
+    moduleId: field.foreignKey({ description: "Parent module" }),
+    title: field.string({ description: "Lesson title" }),
+    description: field.string({
+      isOptional: true,
+      description: "Lesson description"
+    }),
+    type: field.enum("LessonType", {
+      default: "CONTENT",
+      description: "Lesson type"
+    }),
+    order: field.int({ default: 0, description: "Display order" }),
+    estimatedDuration: field.int({
+      isOptional: true,
+      description: "Estimated duration in minutes"
+    }),
+    xpReward: field.int({
+      default: 10,
+      description: "XP awarded on completion"
+    }),
+    isFree: field.boolean({
+      default: false,
+      description: "Whether lesson is free preview"
+    }),
+    isRequired: field.boolean({
+      default: true,
+      description: "Whether lesson is required for completion"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    module: field.belongsTo("CourseModule", ["moduleId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    contents: field.hasMany("LessonContent"),
+    progress: field.hasMany("LessonProgress"),
+    quizzes: field.hasMany("Quiz")
+  },
+  indexes: [index.on(["moduleId", "order"]), index.on(["type"])],
+  enums: [LessonTypeEnum]
+});
+var LessonContentEntity = defineEntity({
+  name: "LessonContent",
+  description: "Content block within a lesson.",
+  schema: "lssm_learning",
+  map: "lesson_content",
+  fields: {
+    id: field.id({ description: "Unique content identifier" }),
+    lessonId: field.foreignKey({ description: "Parent lesson" }),
+    contentType: field.enum("ContentType", { description: "Content format" }),
+    content: field.string({
+      isOptional: true,
+      description: "Text content (markdown, etc.)"
+    }),
+    mediaUrl: field.string({
+      isOptional: true,
+      description: "Media URL for video/audio"
+    }),
+    embedData: field.json({
+      isOptional: true,
+      description: "Embed data for external content"
+    }),
+    order: field.int({ default: 0, description: "Display order" }),
+    duration: field.int({
+      isOptional: true,
+      description: "Content duration in seconds"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    lesson: field.belongsTo("Lesson", ["lessonId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [index.on(["lessonId", "order"])],
+  enums: [ContentTypeEnum]
+});
+var courseEntities = [
+  CourseEntity,
+  CourseModuleEntity,
+  LessonEntity,
+  LessonContentEntity
+];
+var courseEnums = [
+  CourseDifficultyEnum,
+  CourseStatusEnum,
+  LessonTypeEnum,
+  ContentTypeEnum
+];
+export {
+  courseEnums,
+  courseEntities,
+  LessonTypeEnum,
+  LessonEntity,
+  LessonContentEntity,
+  CourseStatusEnum,
+  CourseModuleEntity,
+  CourseEntity,
+  CourseDifficultyEnum,
+  ContentTypeEnum
+};

package/dist/browser/entities/flashcard.js

@@ -0,0 +1,222 @@
+// src/entities/flashcard.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var CardRatingEnum = defineEntityEnum({
+  name: "CardRating",
+  values: ["AGAIN", "HARD", "GOOD", "EASY"],
+  schema: "lssm_learning",
+  description: "Rating for a flashcard review."
+});
+var DeckEntity = defineEntity({
+  name: "Deck",
+  description: "A collection of flashcards.",
+  schema: "lssm_learning",
+  map: "deck",
+  fields: {
+    id: field.id({ description: "Unique deck identifier" }),
+    ownerId: field.foreignKey({ description: "Deck owner (learner)" }),
+    title: field.string({ description: "Deck title" }),
+    description: field.string({
+      isOptional: true,
+      description: "Deck description"
+    }),
+    category: field.string({ isOptional: true, description: "Deck category" }),
+    tags: field.json({ isOptional: true, description: "Tags for discovery" }),
+    isPublic: field.boolean({
+      default: false,
+      description: "Whether deck is publicly visible"
+    }),
+    cardCount: field.int({ default: 0, description: "Number of cards" }),
+    coverImageUrl: field.string({
+      isOptional: true,
+      description: "Cover image URL"
+    }),
+    orgId: field.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    newCardsPerDay: field.int({
+      default: 20,
+      description: "New cards to introduce per day"
+    }),
+    reviewsPerDay: field.int({
+      default: 100,
+      description: "Maximum reviews per day"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    owner: field.belongsTo("Learner", ["ownerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    cards: field.hasMany("Card")
+  },
+  indexes: [
+    index.on(["ownerId"]),
+    index.on(["isPublic", "category"]),
+    index.on(["orgId"])
+  ]
+});
+var CardEntity = defineEntity({
+  name: "Card",
+  description: "An individual flashcard.",
+  schema: "lssm_learning",
+  map: "card",
+  fields: {
+    id: field.id({ description: "Unique card identifier" }),
+    deckId: field.foreignKey({ description: "Parent deck" }),
+    front: field.string({ description: "Front of card (question)" }),
+    back: field.string({ description: "Back of card (answer)" }),
+    hints: field.json({ isOptional: true, description: "Hints for the card" }),
+    explanation: field.string({
+      isOptional: true,
+      description: "Detailed explanation"
+    }),
+    frontMediaUrl: field.string({
+      isOptional: true,
+      description: "Media for front"
+    }),
+    backMediaUrl: field.string({
+      isOptional: true,
+      description: "Media for back"
+    }),
+    audioUrl: field.string({
+      isOptional: true,
+      description: "Audio pronunciation"
+    }),
+    tags: field.json({ isOptional: true, description: "Card tags" }),
+    difficulty: field.int({ default: 0, description: "Card difficulty (0-5)" }),
+    order: field.int({ default: 0, description: "Card order in deck" }),
+    isSuspended: field.boolean({
+      default: false,
+      description: "Whether card is suspended"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    deck: field.belongsTo("Deck", ["deckId"], ["id"], { onDelete: "Cascade" }),
+    reviews: field.hasMany("CardReview"),
+    schedules: field.hasMany("CardSchedule")
+  },
+  indexes: [index.on(["deckId", "order"]), index.on(["isSuspended"])]
+});
+var CardReviewEntity = defineEntity({
+  name: "CardReview",
+  description: "A single review of a flashcard.",
+  schema: "lssm_learning",
+  map: "card_review",
+  fields: {
+    id: field.id({ description: "Unique review identifier" }),
+    learnerId: field.foreignKey({ description: "Reviewer" }),
+    cardId: field.foreignKey({ description: "Reviewed card" }),
+    rating: field.enum("CardRating", { description: "Review rating" }),
+    responseTimeMs: field.int({
+      isOptional: true,
+      description: "Time to respond in ms"
+    }),
+    intervalBefore: field.int({ description: "Interval before review (days)" }),
+    easeFactorBefore: field.decimal({
+      description: "Ease factor before review"
+    }),
+    intervalAfter: field.int({ description: "Interval after review (days)" }),
+    easeFactorAfter: field.decimal({ description: "Ease factor after review" }),
+    reviewType: field.string({
+      default: '"review"',
+      description: "Type: new, learning, review, relearning"
+    }),
+    reviewedAt: field.dateTime({ description: "When reviewed" }),
+    createdAt: field.createdAt(),
+    learner: field.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    card: field.belongsTo("Card", ["cardId"], ["id"], { onDelete: "Cascade" })
+  },
+  indexes: [
+    index.on(["learnerId", "reviewedAt"]),
+    index.on(["cardId", "reviewedAt"]),
+    index.on(["rating"])
+  ],
+  enums: [CardRatingEnum]
+});
+var CardScheduleEntity = defineEntity({
+  name: "CardSchedule",
+  description: "SRS schedule for a learner/card pair.",
+  schema: "lssm_learning",
+  map: "card_schedule",
+  fields: {
+    id: field.id({ description: "Unique schedule identifier" }),
+    learnerId: field.foreignKey({ description: "Learner" }),
+    cardId: field.foreignKey({ description: "Card" }),
+    interval: field.int({
+      default: 0,
+      description: "Current interval in days"
+    }),
+    easeFactor: field.decimal({
+      default: 2.5,
+      description: "Ease factor (SM-2)"
+    }),
+    repetitions: field.int({
+      default: 0,
+      description: "Number of successful repetitions"
+    }),
+    nextReviewAt: field.dateTime({ description: "When next review is due" }),
+    lastReviewAt: field.dateTime({
+      isOptional: true,
+      description: "When last reviewed"
+    }),
+    learningStep: field.int({
+      default: 0,
+      description: "Current learning step"
+    }),
+    isGraduated: field.boolean({
+      default: false,
+      description: "Whether card has graduated"
+    }),
+    isRelearning: field.boolean({
+      default: false,
+      description: "Whether card is being relearned"
+    }),
+    lapses: field.int({
+      default: 0,
+      description: "Number of times card was forgotten"
+    }),
+    reviewCount: field.int({ default: 0, description: "Total review count" }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    learner: field.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    card: field.belongsTo("Card", ["cardId"], ["id"], { onDelete: "Cascade" })
+  },
+  indexes: [
+    index.unique(["learnerId", "cardId"], { name: "card_schedule_unique" }),
+    index.on(["learnerId", "nextReviewAt"]),
+    index.on(["nextReviewAt"])
+  ]
+});
+var flashcardEntities = [
+  DeckEntity,
+  CardEntity,
+  CardReviewEntity,
+  CardScheduleEntity
+];
+var flashcardEnums = [CardRatingEnum];
+export {
+  flashcardEnums,
+  flashcardEntities,
+  DeckEntity,
+  CardScheduleEntity,
+  CardReviewEntity,
+  CardRatingEnum,
+  CardEntity
+};