coursewatcher 1.3.1 → 2.0.0

package/src/models/database.js

@@ -1,169 +0,0 @@
-/**
- * Database Module
- * 
- * SQLite database connection manager using better-sqlite3.
- * Handles schema creation and provides query methods.
- * 
- * @module models/database
- */
-
-const Database = require('better-sqlite3');
-const path = require('path');
-const fs = require('fs');
-const { getDbPath, getDataFolder } = require('../utils/config');
-const { DatabaseError } = require('../utils/errors');
-
-/**
- * Database manager class
- */
-class DatabaseManager {
-    /**
-     * Create a new DatabaseManager
-     * @param {string} coursePath - Path to the course directory
-     */
-    constructor(coursePath) {
-        this._coursePath = coursePath;
-        this._db = null;
-    }
-
-    /**
-     * Initialize the database connection and create schema
-     * @returns {DatabaseManager} This instance for chaining
-     */
-    initialize() {
-        try {
-            // Ensure .coursewatcher folder exists
-            const dataFolder = getDataFolder(this._coursePath);
-            if (!fs.existsSync(dataFolder)) {
-                fs.mkdirSync(dataFolder, { recursive: true });
-            }
-
-            // Open database connection
-            const dbPath = getDbPath(this._coursePath);
-            this._db = new Database(dbPath);
-
-            // Enable foreign keys
-            this._db.pragma('foreign_keys = ON');
-
-            // Create schema
-            this._createSchema();
-
-            return this;
-        } catch (err) {
-            throw new DatabaseError(`Failed to initialize database: ${err.message}`);
-        }
-    }
-
-    /**
-     * Create database schema
-     * @private
-     */
-    _createSchema() {
-        // Modules table
-        this._db.exec(`
-      CREATE TABLE IF NOT EXISTS modules (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        name TEXT NOT NULL,
-        path TEXT NOT NULL UNIQUE,
-        sort_order INTEGER DEFAULT 0,
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-
-        // Videos table
-        this._db.exec(`
-      CREATE TABLE IF NOT EXISTS videos (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        path TEXT NOT NULL UNIQUE,
-        filename TEXT NOT NULL,
-        title TEXT NOT NULL,
-        duration REAL DEFAULT 0,
-        position REAL DEFAULT 0,
-        status TEXT CHECK(status IN ('unwatched', 'in-progress', 'completed')) DEFAULT 'unwatched',
-        module_id INTEGER,
-        sort_order INTEGER DEFAULT 0,
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-        FOREIGN KEY (module_id) REFERENCES modules(id) ON DELETE SET NULL
-      )
-    `);
-
-        // Notes table
-        this._db.exec(`
-      CREATE TABLE IF NOT EXISTS notes (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        video_id INTEGER NOT NULL UNIQUE,
-        content TEXT DEFAULT '',
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-        FOREIGN KEY (video_id) REFERENCES videos(id) ON DELETE CASCADE
-      )
-    `);
-
-        // Create indexes
-        this._db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_videos_module ON videos(module_id);
-      CREATE INDEX IF NOT EXISTS idx_videos_status ON videos(status);
-      CREATE INDEX IF NOT EXISTS idx_videos_path ON videos(path);
-    `);
-    }
-
-    /**
-     * Get a single row from a query
-     * @param {string} sql - SQL query
-     * @param {Array} params - Query parameters
-     * @returns {Object|undefined} The row or undefined
-     */
-    get(sql, params = []) {
-        return this._db.prepare(sql).get(...params);
-    }
-
-    /**
-     * Get all rows from a query
-     * @param {string} sql - SQL query
-     * @param {Array} params - Query parameters
-     * @returns {Array} Array of rows
-     */
-    all(sql, params = []) {
-        return this._db.prepare(sql).all(...params);
-    }
-
-    /**
-     * Run an insert/update/delete query
-     * @param {string} sql - SQL query
-     * @param {Array} params - Query parameters
-     * @returns {Object} Result with changes and lastInsertRowid
-     */
-    run(sql, params = []) {
-        return this._db.prepare(sql).run(...params);
-    }
-
-    /**
-     * Run multiple statements in a transaction
-     * @param {Function} fn - Function containing database operations
-     * @returns {*} Result of the transaction function
-     */
-    transaction(fn) {
-        return this._db.transaction(fn)();
-    }
-
-    /**
-     * Close the database connection
-     */
-    close() {
-        if (this._db) {
-            this._db.close();
-            this._db = null;
-        }
-    }
-
-    /**
-     * Get the course path
-     * @returns {string} The course path
-     */
-    getCoursePath() {
-        return this._coursePath;
-    }
-}
-
-module.exports = { DatabaseManager };

package/src/server.js

@@ -1,179 +0,0 @@
-/**
- * Express Server
- * 
- * Main server configuration and startup.
- * 
- * @module server
- */
-
-const express = require('express');
-const path = require('path');
-const open = require('open');
-
-const { DatabaseManager } = require('./models/database');
-const { VideoService } = require('./services/video-service');
-const { ProgressService } = require('./services/progress-service');
-const { NotesService } = require('./services/notes-service');
-const { createVideoRoutes } = require('./controllers/video-controller');
-const { log, success, error } = require('./utils/logger');
-const chalk = require('chalk');
-
-/**
- * Start the CourseWatcher server
- * @param {Object} options - Server options
- * @param {string} options.coursePath - Path to course directory
- * @param {number} options.port - Server port
- * @param {boolean} options.openBrowser - Whether to open browser
- * @returns {Promise<Object>} Server instance and services
- */
-async function startServer(options) {
-    const { coursePath, port, openBrowser, allowFallback } = options;
-
-    // Initialize database
-    log('Initializing database...');
-    const database = new DatabaseManager(coursePath);
-    database.initialize();
-
-    // Create services
-    const videoService = new VideoService(database);
-    const progressService = new ProgressService(database);
-    const notesService = new NotesService(database);
-
-    // Scan for videos
-    log('Scanning for video files...');
-    const scanResult = videoService.scanVideos();
-    success(`Found ${scanResult.total} videos (${scanResult.added} new, ${scanResult.existing} existing)`);
-
-    // Create Express app
-    const app = express();
-
-    // Configure EJS
-    app.set('view engine', 'ejs');
-    app.set('views', path.join(__dirname, '..', 'views'));
-
-    // Static files
-    app.use('/static', express.static(path.join(__dirname, '..', 'public')));
-    app.use('/lib/plyr', express.static(path.join(__dirname, '..', 'node_modules', 'plyr', 'dist')));
-
-    // Routes
-    app.use('/', createVideoRoutes({
-        videoService,
-        progressService,
-        notesService,
-    }));
-
-    // Error handling middleware
-    app.use((err, req, res, next) => {
-        const statusCode = err.statusCode || 500;
-        const message = err.message || 'Internal Server Error';
-
-        // Log error in development
-        if (process.env.NODE_ENV !== 'production') {
-            error(`${err.name}: ${message}`);
-            if (err.stack) {
-                console.error(err.stack);
-            }
-        }
-
-        // API errors return JSON
-        if (req.path.startsWith('/api/')) {
-            return res.status(statusCode).json({
-                error: true,
-                message,
-            });
-        }
-
-        // Page errors render error page
-        res.status(statusCode).render('pages/error', {
-            title: 'Error',
-            statusCode,
-            message,
-        });
-    });
-
-    // Start server
-    return new Promise((resolve, reject) => {
-        let currentPort = port;
-
-        const start = (retryPort) => {
-            const server = app.listen(retryPort, () => {
-                const url = `http://localhost:${retryPort}`;
-                success(`Server running at ${chalk.cyan(url)}`);
-
-                // Open browser if requested
-                if (openBrowser) {
-                    log('Opening browser...');
-                    open(url).catch(() => {
-                        // Ignore browser open errors
-                    });
-                }
-
-                // Track active connections
-                const sockets = new Set();
-                server.on('connection', (socket) => {
-                    sockets.add(socket);
-                    server.once('close', () => sockets.delete(socket));
-                });
-
-                // Handle graceful shutdown
-                let isShuttingDown = false;
-                const shutdown = async (signal) => {
-                    if (isShuttingDown) return;
-                    isShuttingDown = true;
-
-                    log(`\nShutting down... (${signal})`);
-
-                    // Force exit after timeout if graceful shutdown fails
-                    const forceExitTimeout = setTimeout(() => {
-                        error('Forced shutdown after timeout');
-                        process.exit(1);
-                    }, 5000);
-
-                    // Destroy all active connections
-                    for (const socket of sockets) {
-                        socket.destroy();
-                        sockets.delete(socket);
-                    }
-
-                    database.close();
-                    server.close(() => {
-                        clearTimeout(forceExitTimeout);
-                        success('Server closed');
-                        process.exit(0);
-                    });
-                };
-
-                process.on('SIGINT', () => shutdown('SIGINT'));
-                process.on('SIGTERM', () => shutdown('SIGTERM'));
-
-                resolve({
-                    server,
-                    database,
-                    services: {
-                        videoService,
-                        progressService,
-                        notesService,
-                    },
-                });
-            });
-
-            server.on('error', (err) => {
-                if (err.code === 'EADDRINUSE') {
-                    if (allowFallback) {
-                        log(`Port ${retryPort} is busy, trying ${retryPort + 1}...`);
-                        start(retryPort + 1);
-                    } else {
-                        error(`Port ${retryPort} is already in use`);
-                        reject(err);
-                    }
-                } else {
-                    reject(err);
-                }
-            });
-        };
-
-        start(currentPort);
-    });
-}
-
-module.exports = { startServer };

package/src/services/notes-service.js

@@ -1,97 +0,0 @@
-/**
- * Notes Service
- * 
- * Handles per-video notes with Markdown support.
- * 
- * @module services/notes-service
- */
-
-const { NotFoundError } = require('../utils/errors');
-
-/**
- * Notes service class
- */
-class NotesService {
-    /**
-     * Create a new NotesService
-     * @param {DatabaseManager} database - Database manager instance
-     */
-    constructor(database) {
-        this._db = database;
-    }
-
-    /**
-     * Get notes for a video
-     * @param {number} videoId - Video ID
-     * @returns {Object} Notes object
-     */
-    getNotes(videoId) {
-        // Verify video exists
-        const video = this._db.get('SELECT id FROM videos WHERE id = ?', [videoId]);
-        if (!video) {
-            throw new NotFoundError(`Video with id ${videoId}`);
-        }
-
-        const notes = this._db.get(
-            'SELECT * FROM notes WHERE video_id = ?',
-            [videoId]
-        );
-
-        return notes || { video_id: videoId, content: '' };
-    }
-
-    /**
-     * Save notes for a video
-     * @param {number} videoId - Video ID
-     * @param {string} content - Note content (Markdown)
-     * @returns {Object} Updated notes
-     */
-    saveNotes(videoId, content) {
-        // Verify video exists
-        const video = this._db.get('SELECT id FROM videos WHERE id = ?', [videoId]);
-        if (!video) {
-            throw new NotFoundError(`Video with id ${videoId}`);
-        }
-
-        // Upsert notes
-        this._db.run(
-            `INSERT INTO notes (video_id, content, updated_at)
-       VALUES (?, ?, CURRENT_TIMESTAMP)
-       ON CONFLICT(video_id) DO UPDATE SET
-         content = excluded.content,
-         updated_at = CURRENT_TIMESTAMP`,
-            [videoId, content]
-        );
-
-        return this.getNotes(videoId);
-    }
-
-    /**
-     * Delete notes for a video
-     * @param {number} videoId - Video ID
-     * @returns {boolean} True if deleted
-     */
-    deleteNotes(videoId) {
-        const result = this._db.run(
-            'DELETE FROM notes WHERE video_id = ?',
-            [videoId]
-        );
-        return result.changes > 0;
-    }
-
-    /**
-     * Get all videos with notes
-     * @returns {Array} Videos with notes
-     */
-    getVideosWithNotes() {
-        return this._db.all(
-            `SELECT v.*, n.content as notes_content
-       FROM videos v
-       INNER JOIN notes n ON v.id = n.video_id
-       WHERE n.content != ''
-       ORDER BY v.sort_order, v.filename`
-        );
-    }
-}
-
-module.exports = { NotesService };

package/src/services/progress-service.js

@@ -1,169 +0,0 @@
-/**
- * Progress Service
- * 
- * Handles video playback progress tracking and status updates.
- * 
- * @module services/progress-service
- */
-
-const { config } = require('../utils/config');
-const { NotFoundError, ValidationError } = require('../utils/errors');
-
-/**
- * Progress service class
- */
-class ProgressService {
-    /**
-     * Create a new ProgressService
-     * @param {DatabaseManager} database - Database manager instance
-     */
-    constructor(database) {
-        this._db = database;
-    }
-
-    /**
-     * Update the playback position for a video
-     * @param {number} videoId - Video ID
-     * @param {number} position - Current position in seconds
-     * @param {number} [duration] - Video duration in seconds
-     * @returns {Object} Updated video
-     */
-    updatePosition(videoId, position, duration = null) {
-        // Validate inputs
-        if (typeof position !== 'number' || position < 0) {
-            throw new ValidationError('Position must be a non-negative number');
-        }
-
-        // Get current video
-        const video = this._db.get('SELECT * FROM videos WHERE id = ?', [videoId]);
-        if (!video) {
-            throw new NotFoundError(`Video with id ${videoId}`);
-        }
-
-        // Determine new status based on position
-        let newStatus = video.status;
-        const videoDuration = typeof duration === 'number' && !Number.isNaN(duration)
-            ? duration
-            : video.duration;
-        const isShortVideo = videoDuration > 0
-            && videoDuration < config.shortVideoResumeCutoffSeconds;
-        const completionPosition = videoDuration * config.completionThreshold;
-
-        if (videoDuration > 0) {
-            const watchPercent = position / videoDuration;
-
-            if (watchPercent >= config.completionThreshold) {
-                newStatus = 'completed';
-            } else if (position > 0) {
-                newStatus = 'in-progress';
-            }
-        } else if (position > 0 && video.status === 'unwatched') {
-            newStatus = 'in-progress';
-        }
-
-        const shouldPreserveCompletedProgress = video.status === 'completed'
-            && videoDuration > 0
-            && position < completionPosition;
-
-        if (shouldPreserveCompletedProgress) {
-            newStatus = 'completed';
-        }
-
-        let newPosition = position;
-
-        if (shouldPreserveCompletedProgress) {
-            newPosition = video.position;
-        } else if (isShortVideo && newStatus !== 'completed') {
-            newPosition = 0;
-        }
-
-        // Update database
-        this._db.run(
-            `UPDATE videos 
-       SET position = ?, 
-           duration = COALESCE(?, duration),
-           status = ?,
-           updated_at = CURRENT_TIMESTAMP
-       WHERE id = ?`,
-            [newPosition, duration, newStatus, videoId]
-        );
-
-        return this._db.get('SELECT * FROM videos WHERE id = ?', [videoId]);
-    }
-
-    /**
-     * Update video status manually
-     * @param {number} videoId - Video ID
-     * @param {string} status - New status
-     * @returns {Object} Updated video
-     */
-    updateStatus(videoId, status) {
-        const validStatuses = ['unwatched', 'in-progress', 'completed'];
-
-        if (!validStatuses.includes(status)) {
-            throw new ValidationError(
-                `Invalid status. Must be one of: ${validStatuses.join(', ')}`
-            );
-        }
-
-        const video = this._db.get('SELECT * FROM videos WHERE id = ?', [videoId]);
-        if (!video) {
-            throw new NotFoundError(`Video with id ${videoId}`);
-        }
-
-        // Reset position if marking as unwatched
-        const newPosition = status === 'unwatched' ? 0 : video.position;
-
-        this._db.run(
-            `UPDATE videos 
-       SET status = ?, 
-           position = ?,
-           updated_at = CURRENT_TIMESTAMP
-       WHERE id = ?`,
-            [status, newPosition, videoId]
-        );
-
-        return this._db.get('SELECT * FROM videos WHERE id = ?', [videoId]);
-    }
-
-    /**
-     * Mark video as completed
-     * @param {number} videoId - Video ID
-     * @returns {Object} Updated video
-     */
-    markCompleted(videoId) {
-        return this.updateStatus(videoId, 'completed');
-    }
-
-    /**
-     * Mark video as unwatched (reset progress)
-     * @param {number} videoId - Video ID
-     * @returns {Object} Updated video
-     */
-    markUnwatched(videoId) {
-        return this.updateStatus(videoId, 'unwatched');
-    }
-
-    /**
-     * Get video progress info
-     * @param {number} videoId - Video ID
-     * @returns {Object} Progress info
-     */
-    getProgress(videoId) {
-        const video = this._db.get('SELECT * FROM videos WHERE id = ?', [videoId]);
-        if (!video) {
-            throw new NotFoundError(`Video with id ${videoId}`);
-        }
-
-        return {
-            position: video.position,
-            duration: video.duration,
-            status: video.status,
-            percentWatched: video.duration > 0
-                ? Math.round((video.position / video.duration) * 100)
-                : 0,
-        };
-    }
-}
-
-module.exports = { ProgressService };