@contractspec/module.learning-journey 1.57.0 → 1.58.0

package/dist/browser/entities/learner.js

@@ -0,0 +1,329 @@
+// src/entities/learner.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var EnrollmentStatusEnum = defineEntityEnum({
+  name: "EnrollmentStatus",
+  values: [
+    "ENROLLED",
+    "IN_PROGRESS",
+    "COMPLETED",
+    "DROPPED",
+    "EXPIRED"
+  ],
+  schema: "lssm_learning",
+  description: "Status of a course enrollment."
+});
+var ProgressStatusEnum = defineEntityEnum({
+  name: "ProgressStatus",
+  values: ["NOT_STARTED", "IN_PROGRESS", "COMPLETED", "SKIPPED"],
+  schema: "lssm_learning",
+  description: "Status of lesson progress."
+});
+var LearnerEntity = defineEntity({
+  name: "Learner",
+  description: "A learner profile.",
+  schema: "lssm_learning",
+  map: "learner",
+  fields: {
+    id: field.id({ description: "Unique learner identifier" }),
+    userId: field.string({ isUnique: true, description: "Associated user ID" }),
+    displayName: field.string({
+      isOptional: true,
+      description: "Display name"
+    }),
+    avatarUrl: field.string({ isOptional: true, description: "Avatar URL" }),
+    bio: field.string({ isOptional: true, description: "Short bio" }),
+    level: field.int({ default: 1, description: "Current level" }),
+    totalXp: field.int({ default: 0, description: "Total XP earned" }),
+    currentStreak: field.int({
+      default: 0,
+      description: "Current streak days"
+    }),
+    longestStreak: field.int({
+      default: 0,
+      description: "Longest streak ever"
+    }),
+    lastActivityAt: field.dateTime({
+      isOptional: true,
+      description: "Last learning activity"
+    }),
+    timezone: field.string({
+      default: '"UTC"',
+      description: "Learner timezone"
+    }),
+    dailyGoalXp: field.int({ default: 50, description: "Daily XP goal" }),
+    reminderEnabled: field.boolean({
+      default: true,
+      description: "Enable reminders"
+    }),
+    reminderTime: field.string({
+      isOptional: true,
+      description: "Preferred reminder time"
+    }),
+    orgId: field.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    enrollments: field.hasMany("Enrollment"),
+    lessonProgress: field.hasMany("LessonProgress"),
+    achievements: field.hasMany("LearnerAchievement"),
+    decks: field.hasMany("Deck"),
+    profile: field.hasOne("LearnerProfile")
+  },
+  indexes: [
+    index.on(["orgId"]),
+    index.on(["totalXp"]),
+    index.on(["level"]),
+    index.on(["currentStreak"])
+  ]
+});
+var EnrollmentEntity = defineEntity({
+  name: "Enrollment",
+  description: "A learner enrollment in a course.",
+  schema: "lssm_learning",
+  map: "enrollment",
+  fields: {
+    id: field.id({ description: "Unique enrollment identifier" }),
+    learnerId: field.foreignKey({ description: "Enrolled learner" }),
+    courseId: field.foreignKey({ description: "Enrolled course" }),
+    status: field.enum("EnrollmentStatus", {
+      default: "ENROLLED",
+      description: "Enrollment status"
+    }),
+    progress: field.int({
+      default: 0,
+      description: "Completion percentage (0-100)"
+    }),
+    completedLessons: field.int({
+      default: 0,
+      description: "Number of completed lessons"
+    }),
+    totalLessons: field.int({
+      default: 0,
+      description: "Total lessons in course"
+    }),
+    xpEarned: field.int({
+      default: 0,
+      description: "XP earned in this course"
+    }),
+    startedAt: field.dateTime({
+      isOptional: true,
+      description: "When learner started"
+    }),
+    completedAt: field.dateTime({
+      isOptional: true,
+      description: "When learner completed"
+    }),
+    lastAccessedAt: field.dateTime({
+      isOptional: true,
+      description: "Last access time"
+    }),
+    certificateId: field.string({
+      isOptional: true,
+      description: "Issued certificate ID"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    learner: field.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    course: field.belongsTo("Course", ["courseId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index.unique(["learnerId", "courseId"], { name: "enrollment_unique" }),
+    index.on(["learnerId", "status"]),
+    index.on(["courseId", "status"])
+  ],
+  enums: [EnrollmentStatusEnum]
+});
+var LessonProgressEntity = defineEntity({
+  name: "LessonProgress",
+  description: "Progress tracking for a lesson.",
+  schema: "lssm_learning",
+  map: "lesson_progress",
+  fields: {
+    id: field.id({ description: "Unique progress identifier" }),
+    learnerId: field.foreignKey({ description: "Learner" }),
+    lessonId: field.foreignKey({ description: "Lesson" }),
+    status: field.enum("ProgressStatus", {
+      default: "NOT_STARTED",
+      description: "Progress status"
+    }),
+    progress: field.int({
+      default: 0,
+      description: "Completion percentage (0-100)"
+    }),
+    score: field.int({
+      isOptional: true,
+      description: "Score achieved (for quizzes)"
+    }),
+    attempts: field.int({ default: 0, description: "Number of attempts" }),
+    bestScore: field.int({
+      isOptional: true,
+      description: "Best score across attempts"
+    }),
+    timeSpent: field.int({ default: 0, description: "Time spent in seconds" }),
+    xpEarned: field.int({
+      default: 0,
+      description: "XP earned from this lesson"
+    }),
+    startedAt: field.dateTime({
+      isOptional: true,
+      description: "When started"
+    }),
+    completedAt: field.dateTime({
+      isOptional: true,
+      description: "When completed"
+    }),
+    lastAccessedAt: field.dateTime({
+      isOptional: true,
+      description: "Last access time"
+    }),
+    bookmarks: field.json({
+      isOptional: true,
+      description: "Content bookmarks"
+    }),
+    notes: field.string({ isOptional: true, description: "Learner notes" }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    learner: field.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    lesson: field.belongsTo("Lesson", ["lessonId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index.unique(["learnerId", "lessonId"], { name: "lesson_progress_unique" }),
+    index.on(["learnerId", "status"]),
+    index.on(["lessonId"])
+  ],
+  enums: [ProgressStatusEnum]
+});
+var ModuleCompletionEntity = defineEntity({
+  name: "ModuleCompletion",
+  description: "Module completion record.",
+  schema: "lssm_learning",
+  map: "module_completion",
+  fields: {
+    id: field.id({ description: "Unique completion identifier" }),
+    learnerId: field.foreignKey({ description: "Learner" }),
+    moduleId: field.foreignKey({ description: "Module" }),
+    score: field.int({ isOptional: true, description: "Average score" }),
+    xpEarned: field.int({ default: 0, description: "XP earned" }),
+    timeSpent: field.int({ default: 0, description: "Time spent in seconds" }),
+    completedAt: field.dateTime({ description: "When completed" }),
+    createdAt: field.createdAt(),
+    learner: field.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    module: field.belongsTo("CourseModule", ["moduleId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index.unique(["learnerId", "moduleId"], {
+      name: "module_completion_unique"
+    }),
+    index.on(["learnerId", "completedAt"])
+  ]
+});
+var CertificateEntity = defineEntity({
+  name: "Certificate",
+  description: "Course completion certificate.",
+  schema: "lssm_learning",
+  map: "certificate",
+  fields: {
+    id: field.id({ description: "Unique certificate identifier" }),
+    learnerId: field.foreignKey({ description: "Certificate holder" }),
+    courseId: field.foreignKey({ description: "Completed course" }),
+    enrollmentId: field.foreignKey({ description: "Associated enrollment" }),
+    certificateNumber: field.string({
+      isUnique: true,
+      description: "Unique certificate number"
+    }),
+    title: field.string({ description: "Certificate title" }),
+    description: field.string({
+      isOptional: true,
+      description: "Certificate description"
+    }),
+    score: field.int({ isOptional: true, description: "Final score" }),
+    grade: field.string({ isOptional: true, description: "Grade awarded" }),
+    issuedAt: field.dateTime({ description: "When issued" }),
+    validUntil: field.dateTime({
+      isOptional: true,
+      description: "Expiration date"
+    }),
+    verificationUrl: field.string({
+      isOptional: true,
+      description: "Verification URL"
+    }),
+    credentialHash: field.string({
+      isOptional: true,
+      description: "Credential hash for verification"
+    }),
+    isRevoked: field.boolean({
+      default: false,
+      description: "Whether certificate is revoked"
+    }),
+    revokedAt: field.dateTime({
+      isOptional: true,
+      description: "When revoked"
+    }),
+    revokedReason: field.string({
+      isOptional: true,
+      description: "Revocation reason"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    learner: field.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    course: field.belongsTo("Course", ["courseId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index.on(["learnerId"]),
+    index.on(["courseId"]),
+    index.on(["issuedAt"])
+  ]
+});
+var learnerEntities = [
+  LearnerEntity,
+  EnrollmentEntity,
+  LessonProgressEntity,
+  ModuleCompletionEntity,
+  CertificateEntity
+];
+var learnerEnums = [EnrollmentStatusEnum, ProgressStatusEnum];
+export {
+  learnerEnums,
+  learnerEntities,
+  ProgressStatusEnum,
+  ModuleCompletionEntity,
+  LessonProgressEntity,
+  LearnerEntity,
+  EnrollmentStatusEnum,
+  EnrollmentEntity,
+  CertificateEntity
+};

package/dist/browser/entities/onboarding.js

@@ -0,0 +1,301 @@
+// src/entities/onboarding.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var OnboardingStepStatusEnum = defineEntityEnum({
+  name: "OnboardingStepStatus",
+  values: ["PENDING", "IN_PROGRESS", "COMPLETED", "SKIPPED"],
+  schema: "lssm_learning",
+  description: "Status of an onboarding step."
+});
+var OnboardingTrackEntity = defineEntity({
+  name: "OnboardingTrack",
+  description: "An onboarding track for a product.",
+  schema: "lssm_learning",
+  map: "onboarding_track",
+  fields: {
+    id: field.id({ description: "Unique track identifier" }),
+    productId: field.string({ description: "Product this track is for" }),
+    name: field.string({ description: "Track name" }),
+    description: field.string({
+      isOptional: true,
+      description: "Track description"
+    }),
+    targetUserSegment: field.string({
+      isOptional: true,
+      description: "Target user segment"
+    }),
+    targetRole: field.string({
+      isOptional: true,
+      description: "Target user role"
+    }),
+    welcomeTitle: field.string({
+      isOptional: true,
+      description: "Welcome message title"
+    }),
+    welcomeMessage: field.string({
+      isOptional: true,
+      description: "Welcome message"
+    }),
+    completionTitle: field.string({
+      isOptional: true,
+      description: "Completion message title"
+    }),
+    completionMessage: field.string({
+      isOptional: true,
+      description: "Completion message"
+    }),
+    isActive: field.boolean({
+      default: true,
+      description: "Whether track is active"
+    }),
+    isRequired: field.boolean({
+      default: false,
+      description: "Whether track is required"
+    }),
+    canSkip: field.boolean({
+      default: true,
+      description: "Whether steps can be skipped"
+    }),
+    totalXp: field.int({
+      default: 100,
+      description: "Total XP for completing track"
+    }),
+    completionXpBonus: field.int({
+      isOptional: true,
+      description: "Bonus XP for completing track"
+    }),
+    completionBadgeKey: field.string({
+      isOptional: true,
+      description: "Badge awarded on completion"
+    }),
+    streakHoursWindow: field.int({
+      isOptional: true,
+      description: "Hours window to finish for streak bonus"
+    }),
+    streakBonusXp: field.int({
+      isOptional: true,
+      description: "Bonus XP if completed within streak window"
+    }),
+    orgId: field.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    steps: field.hasMany("OnboardingStep"),
+    progress: field.hasMany("OnboardingProgress")
+  },
+  indexes: [
+    index.on(["productId", "isActive"]),
+    index.on(["orgId"]),
+    index.unique(["productId", "targetUserSegment", "targetRole"], {
+      name: "onboarding_track_target"
+    })
+  ]
+});
+var OnboardingStepEntity = defineEntity({
+  name: "OnboardingStep",
+  description: "A step in an onboarding track.",
+  schema: "lssm_learning",
+  map: "onboarding_step",
+  fields: {
+    id: field.id({ description: "Unique step identifier" }),
+    trackId: field.foreignKey({ description: "Parent track" }),
+    title: field.string({ description: "Step title" }),
+    description: field.string({
+      isOptional: true,
+      description: "Step description"
+    }),
+    instructions: field.string({
+      isOptional: true,
+      description: "How to complete the step"
+    }),
+    helpUrl: field.string({
+      isOptional: true,
+      description: "Link to help documentation"
+    }),
+    order: field.int({ default: 0, description: "Display order" }),
+    triggerEvent: field.string({
+      isOptional: true,
+      description: "Event that triggers step start"
+    }),
+    completionEvent: field.string({
+      description: "Event that completes the step"
+    }),
+    completionEventVersion: field.int({
+      isOptional: true,
+      description: "Version of the completion event"
+    }),
+    completionSourceModule: field.string({
+      isOptional: true,
+      description: "Module emitting the completion event"
+    }),
+    completionEventFilter: field.json({
+      isOptional: true,
+      description: "Filter for completion event"
+    }),
+    actionUrl: field.string({
+      isOptional: true,
+      description: "URL to navigate to complete"
+    }),
+    actionLabel: field.string({
+      isOptional: true,
+      description: "Action button label"
+    }),
+    highlightSelector: field.string({
+      isOptional: true,
+      description: "CSS selector to highlight"
+    }),
+    tooltipPosition: field.string({
+      isOptional: true,
+      description: "Tooltip position"
+    }),
+    xpReward: field.int({ default: 10, description: "XP for completing step" }),
+    isRequired: field.boolean({
+      default: true,
+      description: "Whether step is required"
+    }),
+    canSkip: field.boolean({
+      default: true,
+      description: "Whether step can be skipped"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    track: field.belongsTo("OnboardingTrack", ["trackId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [index.on(["trackId", "order"]), index.on(["completionEvent"])]
+});
+var OnboardingProgressEntity = defineEntity({
+  name: "OnboardingProgress",
+  description: "Tracks user progress through an onboarding track.",
+  schema: "lssm_learning",
+  map: "onboarding_progress",
+  fields: {
+    id: field.id({ description: "Unique progress identifier" }),
+    learnerId: field.foreignKey({ description: "Learner" }),
+    trackId: field.foreignKey({ description: "Onboarding track" }),
+    currentStepId: field.string({
+      isOptional: true,
+      description: "Current step ID"
+    }),
+    completedSteps: field.json({
+      default: "[]",
+      description: "Array of completed step IDs"
+    }),
+    skippedSteps: field.json({
+      default: "[]",
+      description: "Array of skipped step IDs"
+    }),
+    progress: field.int({
+      default: 0,
+      description: "Completion percentage (0-100)"
+    }),
+    isCompleted: field.boolean({
+      default: false,
+      description: "Whether track is completed"
+    }),
+    xpEarned: field.int({ default: 0, description: "XP earned from track" }),
+    startedAt: field.dateTime({ description: "When user started" }),
+    completedAt: field.dateTime({
+      isOptional: true,
+      description: "When user completed"
+    }),
+    lastActivityAt: field.dateTime({
+      isOptional: true,
+      description: "Last activity"
+    }),
+    isDismissed: field.boolean({
+      default: false,
+      description: "Whether user dismissed onboarding"
+    }),
+    dismissedAt: field.dateTime({
+      isOptional: true,
+      description: "When dismissed"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    learner: field.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    track: field.belongsTo("OnboardingTrack", ["trackId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index.unique(["learnerId", "trackId"], {
+      name: "onboarding_progress_unique"
+    }),
+    index.on(["learnerId", "isCompleted"]),
+    index.on(["trackId"])
+  ],
+  enums: [OnboardingStepStatusEnum]
+});
+var OnboardingStepCompletionEntity = defineEntity({
+  name: "OnboardingStepCompletion",
+  description: "Individual step completion record.",
+  schema: "lssm_learning",
+  map: "onboarding_step_completion",
+  fields: {
+    id: field.id({ description: "Unique completion identifier" }),
+    progressId: field.foreignKey({ description: "Parent progress record" }),
+    stepId: field.foreignKey({ description: "Completed step" }),
+    status: field.enum("OnboardingStepStatus", {
+      description: "Completion status"
+    }),
+    xpEarned: field.int({ default: 0, description: "XP earned" }),
+    triggeringEvent: field.string({
+      isOptional: true,
+      description: "Event that triggered completion"
+    }),
+    eventPayload: field.json({
+      isOptional: true,
+      description: "Event payload"
+    }),
+    completedAt: field.dateTime({ description: "When completed" }),
+    createdAt: field.createdAt(),
+    progress: field.belongsTo("OnboardingProgress", ["progressId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    step: field.belongsTo("OnboardingStep", ["stepId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index.unique(["progressId", "stepId"], { name: "step_completion_unique" }),
+    index.on(["completedAt"])
+  ]
+});
+var onboardingEntities = [
+  OnboardingTrackEntity,
+  OnboardingStepEntity,
+  OnboardingProgressEntity,
+  OnboardingStepCompletionEntity
+];
+var onboardingEnums = [OnboardingStepStatusEnum];
+export {
+  onboardingEnums,
+  onboardingEntities,
+  OnboardingTrackEntity,
+  OnboardingStepStatusEnum,
+  OnboardingStepEntity,
+  OnboardingStepCompletionEntity,
+  OnboardingProgressEntity
+};