Students Plugin

The Students Plugin provides a complete student and course management system with enrollment tracking, progress monitoring, assignments, grades, and certifications.

Installation

npm install @deessejs/plugin-students

Configuration

// deesse.config.ts
import { defineConfig } from '@deessejs/core'
import { studentsPlugin } from '@deessejs/plugin-students'

export const config = defineConfig({
  plugins: [
    studentsPlugin({
      // Enrollment settings
      enrollment: {
        autoApprove: false,      // Require admin approval
        maxCourses: 10,          // Max courses per student
        allowWaitlist: true,     // Enable course waitlists
        waitlistLimit: 50,
      },

      // Progress tracking
      progress: {
        autoCalculate: true,     // Auto-calculate progress
        completionThreshold: 80, // % required to complete
        allowSelfPaced: true,    // Students can work at own pace
      },

      // Grading
      grading: {
        scale: 'percentage',     // 'percentage', 'letter', 'gpa'
        passingScore: 60,
        allowRetakes: true,
        maxRetakes: 3,
      },

      // Certificates
      certificates: {
        enabled: true,
        autoGenerate: true,      // Auto-generate on completion
        template: 'default',      // Certificate template
        verifyUrl: '/verify/:id', // Certificate verification URL
      },

      // Notifications
      notifications: {
        enrollment: true,
        progress: true,
        assignmentDue: true,
        completion: true,
        certificate: true,
      },
    }),
  ],
})

Collections

Students

Student information and profiles:

{
  name: 'students',
  fields: [
    {
      name: 'user',
      type: 'reference',
      relation: 'users',
      required: true,
      unique: true,
    },
    {
      name: 'studentId',
      type: 'string',
      unique: true,
      admin: {
        description: 'Unique student identifier',
      },
    },
    {
      name: 'status',
      type: 'enum',
      enum: ['active', 'inactive', 'suspended', 'graduated'],
      defaultValue: 'active',
    },
    {
      name: 'enrollmentDate',
      type: 'datetime',
      defaultValue: () => new Date(),
    },
    {
      name: 'phone',
      type: 'string',
    },
    {
      name: 'address',
      type: 'json',
      admin: {
        description: 'Student address object',
      },
    },
    {
      name: 'dateOfBirth',
      type: 'date',
    },
    {
      name: 'emergencyContact',
      type: 'json',
      admin: {
        description: 'Emergency contact information',
      },
    },
    {
      name: 'notes',
      type: 'richtext',
    },
    {
      name: 'metadata',
      type: 'json',
      admin: {
        description: 'Additional student data',
      },
    },
  ],
}

Courses

Course information and curriculum:

{
  name: 'courses',
  fields: [
    {
      name: 'title',
      type: 'string',
      required: true,
    },
    {
      name: 'slug',
      type: 'string',
      unique: true,
    },
    {
      name: 'description',
      type: 'richtext',
    },
    {
      name: 'excerpt',
      type: 'text',
    },
    {
      name: 'thumbnail',
      type: 'media',
    },
    {
      name: 'instructor',
      type: 'reference',
      relation: 'users',
    },
    {
      name: 'category',
      type: 'reference',
      relation: 'courseCategories',
    },
    {
      name: 'level',
      type: 'enum',
      enum: ['beginner', 'intermediate', 'advanced'],
      defaultValue: 'beginner',
    },
    {
      name: 'language',
      type: 'string',
      defaultValue: 'en',
    },
    {
      name: 'duration',
      type: 'number',
      admin: {
        description: 'Duration in hours',
      },
    },
    {
      name: 'price',
      type: 'number',
      defaultValue: 0,
    },
    {
      name: 'capacity',
      type: 'number',
      admin: {
        description: 'Maximum number of students',
      },
    },
    {
      name: 'status',
      type: 'enum',
      enum: ['draft', 'published', 'archived'],
      defaultValue: 'draft',
    },
    {
      name: 'publishedAt',
      type: 'datetime',
    },
    {
      name: 'enrollmentStart',
      type: 'datetime',
    },
    {
      name: 'enrollmentEnd',
      type: 'datetime',
    },
    {
      name: 'startDate',
      type: 'datetime',
    },
    {
      name: 'endDate',
      type: 'datetime',
    },
    {
      name: 'prerequisites',
      type: 'relation',
      relation: 'courses',
      many: true,
      admin: {
        description: 'Required courses before enrollment',
      },
    },
    {
      name: 'learningObjectives',
      type: 'array',
      admin: {
        description: 'Learning outcomes',
      },
    },
    {
      name: 'targetAudience',
      type: 'richtext',
    },
    {
      name: 'requirements',
      type: 'richtext',
    },
    {
      name: 'certificate',
      type: 'boolean',
      defaultValue: true,
      admin: {
        description: 'Offer certificate on completion',
      },
    },
  ],
}

Enrollments

Student enrollment records:

{
  name: 'enrollments',
  fields: [
    {
      name: 'student',
      type: 'reference',
      relation: 'students',
      required: true,
    },
    {
      name: 'course',
      type: 'reference',
      relation: 'courses',
      required: true,
    },
    {
      name: 'status',
      type: 'enum',
      enum: ['pending', 'active', 'completed', 'dropped', 'waitlisted'],
      defaultValue: 'pending',
    },
    {
      name: 'enrolledAt',
      type: 'datetime',
      defaultValue: () => new Date(),
    },
    {
      name: 'completedAt',
      type: 'datetime',
    },
    {
      name: 'progress',
      type: 'number',
      defaultValue: 0,
      admin: {
        description: 'Progress percentage (0-100)',
      },
    },
    {
      name: 'grade',
      type: 'string',
      admin: {
        description: 'Final grade',
      },
    },
    {
      name: 'certificate',
      type: 'reference',
      relation: 'certificates',
    },
    {
      name: 'notes',
      type: 'richtext',
    },
  ],
}

Lessons

Individual course lessons:

{
  name: 'lessons',
  fields: [
    {
      name: 'course',
      type: 'reference',
      relation: 'courses',
      required: true,
    },
    {
      name: 'title',
      type: 'string',
      required: true,
    },
    {
      name: 'slug',
      type: 'string',
    },
    {
      name: 'description',
      type: 'text',
    },
    {
      name: 'content',
      type: 'richtext',
    },
    {
      name: 'order',
      type: 'number',
      defaultValue: 0,
    },
    {
      name: 'duration',
      type: 'number',
      admin: {
        description: 'Duration in minutes',
      },
    },
    {
      name: 'video',
      type: 'string',
      admin: {
        description: 'Video URL or embed code',
      },
    },
    {
      name: 'resources',
      type: 'array',
      admin: {
        description: 'Lesson resources and downloads',
      },
    },
    {
      name: 'isPublished',
      type: 'boolean',
      defaultValue: false,
    },
    {
      name: 'isPreview',
      type: 'boolean',
      defaultValue: false,
      admin: {
        description: 'Free preview lesson',
      },
    },
  ],
}

Assignments

Student assignments:

{
  name: 'assignments',
  fields: [
    {
      name: 'lesson',
      type: 'reference',
      relation: 'lessons',
    },
    {
      name: 'course',
      type: 'reference',
      relation: 'courses',
      required: true,
    },
    {
      name: 'title',
      type: 'string',
      required: true,
    },
    {
      name: 'description',
      type: 'richtext',
    },
    {
      name: 'instructions',
      type: 'richtext',
    },
    {
      name: 'dueDate',
      type: 'datetime',
    },
    {
      name: 'maxScore',
      type: 'number',
      defaultValue: 100,
    },
    {
      name: 'passingScore',
      type: 'number',
      defaultValue: 60,
    },
    {
      name: 'allowLateSubmission',
      type: 'boolean',
      defaultValue: true,
    },
    {
      name: 'latePenalty',
      type: 'number',
      defaultValue: 10,
      admin: {
        description: 'Percentage penalty per day late',
      },
    },
    {
      name: 'order',
      type: 'number',
      defaultValue: 0,
    },
  ],
}

Submissions

Student assignment submissions:

{
  name: 'submissions',
  fields: [
    {
      name: 'assignment',
      type: 'reference',
      relation: 'assignments',
      required: true,
    },
    {
      name: 'student',
      type: 'reference',
      relation: 'students',
      required: true,
    },
    {
      name: 'content',
      type: 'richtext',
    },
    {
      name: 'attachments',
      type: 'array',
      admin: {
        description: 'Uploaded files',
      },
    },
    {
      name: 'submittedAt',
      type: 'datetime',
      defaultValue: () => new Date(),
    },
    {
      name: 'score',
      type: 'number',
    },
    {
      name: 'feedback',
      type: 'richtext',
    },
    {
      name: 'gradedAt',
      type: 'datetime',
    },
    {
      name: 'gradedBy',
      type: 'reference',
      relation: 'users',
    },
    {
      name: 'status',
      type: 'enum',
      enum: ['submitted', 'graded', 'returned', 'late'],
      defaultValue: 'submitted',
    },
  ],
}

Certificates

Completion certificates:

{
  name: 'certificates',
  fields: [
    {
      name: 'student',
      type: 'reference',
      relation: 'students',
      required: true,
    },
    {
      name: 'course',
      type: 'reference',
      relation: 'courses',
      required: true,
    },
    {
      name: 'certificateId',
      type: 'string',
      unique: true,
    },
    {
      name: 'issuedAt',
      type: 'datetime',
      defaultValue: () => new Date(),
    },
    {
      name: 'expiryDate',
      type: 'datetime',
    },
    {
      name: 'score',
      type: 'number',
    },
    {
      name: 'pdfUrl',
      type: 'string',
    },
  ],
}

Admin Pages

Students Dashboard

Student list with filters
Enrollment overview
Progress tracking
Quick actions (enroll, suspend, message)

Courses Management

Course editor
Curriculum builder
Lesson management
Assignment creator

Grading Center

Submission queue
Bulk grading tools
Grade book view
Analytics dashboard

Certificates

Certificate templates
Issuance management
Verification system
PDF generation

API Routes

# Student operations
GET    /api/students
GET    /api/students/:id
POST   /api/students
PUT    /api/students/:id
DELETE /api/students/:id

# Course operations
GET    /api/courses
GET    /api/courses/:slug
GET    /api/courses/:id/lessons
POST   /api/courses/:id/enroll

# Enrollment operations
GET    /api/enrollments
POST   /api/enrollments
PUT    /api/enrollments/:id
DELETE /api/enrollments/:id

# Progress tracking
GET    /api/students/:id/progress
GET    /api/students/:id/courses/:courseId/progress

# Assignments
GET    /api/courses/:courseId/assignments
POST   /api/assignments/:id/submit
GET    /api/submissions
PUT    /api/submissions/:id/grade

# Certificates
GET    /api/students/:id/certificates
GET    /api/certificates/:certificateId
GET    /api/verify/certificate/:id

Frontend Components

CourseCard Component

import { CourseCard } from '@deessejs/plugin-students/components'

export default function CourseList({ courses }) {
  return (
    <div className="grid gap-6 md:grid-cols-2 lg:grid-cols-3">
      {courses.map(course => (
        <CourseCard
          key={course.id}
          course={course}
          showProgress
          showInstructor
          variant="default"
        />
      ))}
    </div>
  )
}

LessonViewer Component

import { LessonViewer } from '@deessejs/plugin-students/components'

export default function LessonPage({ lesson }) {
  return (
    <LessonViewer
      lesson={lesson}
      course={lesson.course}
      enrollment={enrollment}
      markComplete
      showNavigation
    />
  )
}

ProgressTracker Component

import { ProgressTracker } from '@deessejs/plugin-students/components'

export default function StudentDashboard() {
  return (
    <ProgressTracker
      enrollmentId={enrollment.id}
      showLessons
      showAssignments
      variant="detailed"
    />
  )
}

GradeBook Component

import { GradeBook } from '@deessejs/plugin-students/components'

export default function GradesPage() {
  return (
    <GradeBook
      courseId={course.id}
      studentId={student.id}
      showSubmissions
      showFeedback
    />
  )
}

CertificateViewer Component

import { CertificateViewer } from '@deessejs/plugin-students/components'

export default function CertificatePage({ certificate }) {
  return (
    <CertificateViewer
      certificate={certificate}
      showDownload
      showShare
      showVerify
    />
  )
}

Hooks

useEnrollment

'use client'

import { useEnrollment } from '@deessejs/plugin-students/hooks'

export default function CoursePage({ courseId }) {
  const { enrollment, loading, error, enroll, drop } = useEnrollment(courseId)

  if (loading) return <div>Loading...</div>

  return (
    <div>
      {enrollment ? (
        <button onClick={drop}>Drop Course</button>
      ) : (
        <button onClick={enroll}>Enroll Now</button>
      )}
    </div>
  )
}

useProgress

'use client'

import { useProgress } from '@deessejs/plugin-students/hooks'

export default function ProgressBar({ courseId }) {
  const { progress, loading, updateProgress } = useProgress(courseId)

  return (
    <div>
      <progress value={progress.percentage} max={100} />
      <span>{progress.percentage}% Complete</span>
    </div>
  )
}

useSubmissions

'use client'

import { useSubmissions } from '@deessejs/plugin-students/hooks'

export default function AssignmentPage({ assignmentId }) {
  const { submission, submit, loading } = useSubmissions(assignmentId)

  return (
    <form onSubmit={handleSubmit}>
      <textarea onChange={(e) => setContent(e.target.value)} />
      <button type="submit" disabled={loading}>
        Submit Assignment
      </button>
    </form>
  )
}

Server Functions

getStudentProgress

import { getStudentProgress } from '@deessejs/plugin-students/server'

export default async function ProgressPage() {
  const session = await getServerSession()
  const progress = await getStudentProgress(session.user.id)

  return (
    <div>
      <h2>Your Progress</h2>
      {progress.map(p => (
        <div key={p.course.id}>
          <h3>{p.course.title}</h3>
          <progress value={p.percentage} max={100} />
          <span>{p.percentage}%</span>
        </div>
      ))}
    </div>
  )
}

generateCertificate

import { generateCertificate } from '@deessejs/plugin-students/server'

// Auto-generate certificate on course completion
export async function completeCourse(courseId: string) {
  const enrollment = await db.enrollments.findFirst({
    where: {
      courseId,
      student: { user: { id: session.user.id } },
    },
  })

  if (enrollment.progress >= 100) {
    const certificate = await generateCertificate({
      studentId: enrollment.student.id,
      courseId,
      score: enrollment.grade,
    })

    return certificate
  }
}

URL Structure

/courses                        # Course catalog
/courses/:slug                  # Course detail page
/courses/:slug/lessons/:lesson  # Lesson page
/my-learning                    # Student dashboard
/my-learning/:courseId          # Course learning page
/my-learning/certificates       # Student certificates
/verify/certificate/:id         # Certificate verification
/admin/courses                  # Admin courses
/admin/students                 # Admin students
/admin/assignments              # Admin assignments
/admin/grading                  # Grading center
/admin/certificates             # Certificate management

Next Steps

Explore the Affiliates Plugin
Learn about Analytics Plugin
Return to Plugins Overview

Students Plugin

On this page