coursewatcher 1.3.1 → 2.0.0

package/README.md

@@ -5,20 +5,21 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 
-**A CLI tool and web interface for tracking progress in downloaded video courses.**
+**A TypeScript CLI and React web app for tracking progress in downloaded video courses.**
 
 ## Quick Start
 
-```bash
-# Navigate to your course folder
-cd /path/to/my-course
-
-# Run CourseWatcher
-npx coursewatcher
-
-# Or with options
-npx coursewatcher --port 8080 --no-browser
-```
+```bash
+# Navigate to your course folder
+cd /path/to/my-course
+
+# Build once, then run CourseWatcher
+npm run build
+node dist/app/cli/main.js
+
+# Or with options
+node dist/app/cli/main.js --port 8080 --no-browser
+```
 
 ## CLI Options
 
@@ -59,18 +60,20 @@ npm install -g coursewatcher
 | `M` | Mute/Unmute |
 | `F` | Fullscreen |
 
-## Development
-
-```bash
-# Install dependencies
-npm install
-
-# Run in development
-npm run dev
-
-# Run tests
-npm test
-```
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run the TypeScript CLI + Express server with Vite middleware
+npm run dev
+
+# Typecheck, test, and build
+npm run typecheck
+npm test
+npm run build
+```
 
 ## License
 

package/dist/app/cli/main.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const package_info_1 = require("../../platform/config/package-info");
+const logger_1 = require("../../platform/logging/logger");
+const start_server_1 = require("../server/start-server");
+const packageInfo = (0, package_info_1.getPackageInfo)();
+commander_1.program
+    .name('coursewatcher')
+    .description(packageInfo.description)
+    .version(packageInfo.version)
+    .argument('[path]', 'path to course directory', '.')
+    .option('-p, --port <number>', 'server port')
+    .option('--no-browser', 'do not open browser automatically')
+    .action(async (coursePath, options) => {
+    try {
+        const resolvedCoursePath = (0, start_server_1.resolveCoursePath)(coursePath);
+        const isPortSpecified = typeof options.port === 'string';
+        const portOption = options.port;
+        const port = isPortSpecified && portOption ? Number.parseInt(portOption, 10) : (0, start_server_1.getDefaultPort)();
+        (0, logger_1.log)(`Starting CourseWatcher in: ${resolvedCoursePath}`);
+        await (0, start_server_1.startServer)({
+            coursePath: resolvedCoursePath,
+            port,
+            allowFallback: !isPortSpecified,
+            openBrowser: options.browser,
+        });
+    }
+    catch (caughtError) {
+        const message = caughtError instanceof Error ? caughtError.message : 'Unknown error';
+        (0, logger_1.error)(`Failed to start CourseWatcher: ${message}`);
+        process.exit(1);
+    }
+});
+void commander_1.program.parseAsync();

package/dist/app/server/create-app.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCourseWatcherApp = createCourseWatcherApp;
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const express_1 = __importDefault(require("express"));
+const catalog_repository_1 = require("../../modules/catalog/catalog-repository");
+const catalog_service_1 = require("../../modules/catalog/catalog-service");
+const notes_repository_1 = require("../../modules/notes/notes-repository");
+const notes_service_1 = require("../../modules/notes/notes-service");
+const playback_repository_1 = require("../../modules/playback/playback-repository");
+const playback_service_1 = require("../../modules/playback/playback-service");
+const app_config_1 = require("../../platform/config/app-config");
+const app_error_1 = require("../../platform/errors/app-error");
+const logger_1 = require("../../platform/logging/logger");
+async function createCourseWatcherApp(database) {
+    const catalogRepository = new catalog_repository_1.CatalogRepository(database);
+    const notesRepository = new notes_repository_1.NotesRepository(database);
+    const playbackRepository = new playback_repository_1.PlaybackRepository(database);
+    const notesService = new notes_service_1.NotesService(notesRepository);
+    const playbackService = new playback_service_1.PlaybackService(playbackRepository, catalogRepository);
+    const catalogService = new catalog_service_1.CatalogService(catalogRepository, playbackService, notesService);
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json());
+    app.get('/api/catalog', (request, response) => {
+        response.json(catalogService.getCatalog(getQueryValue(request.query.sort)));
+    });
+    app.get('/api/stats', (_request, response) => {
+        response.json(catalogService.getStats());
+    });
+    app.get('/api/search', (request, response) => {
+        response.json(catalogService.searchVideos(getQueryValue(request.query.q) ?? ''));
+    });
+    app.get('/api/videos/:id', (request, response) => {
+        response.json(catalogService.getPlayerPayload(getNumericRouteParam(request.params.id)));
+    });
+    app.get('/api/videos/:id/stream', (request, response) => {
+        response.sendFile(catalogService.getVideoPath(getNumericRouteParam(request.params.id)));
+    });
+    app.post('/api/videos/:id/progress', (request, response) => {
+        const videoId = getNumericRouteParam(request.params.id);
+        const { duration, position } = request.body;
+        response.json(playbackService.updatePosition(videoId, position ?? 0, duration ?? null));
+    });
+    app.post('/api/videos/:id/status', (request, response) => {
+        const videoId = getNumericRouteParam(request.params.id);
+        const { status } = request.body;
+        response.json(playbackService.updateStatus(videoId, status ?? 'unwatched'));
+    });
+    app.get('/api/videos/:id/notes', (request, response) => {
+        response.json(notesService.getNotes(getNumericRouteParam(request.params.id)));
+    });
+    app.post('/api/videos/:id/notes', (request, response) => {
+        const videoId = getNumericRouteParam(request.params.id);
+        const { content } = request.body;
+        response.json({
+            success: true,
+            notes: notesService.saveNotes(videoId, content ?? ''),
+        });
+    });
+    await registerWebApplication(app);
+    app.use((caughtError, request, response, _next) => {
+        const appError = normalizeError(caughtError);
+        if (process.env.NODE_ENV !== 'production') {
+            (0, logger_1.error)(`${appError.name}: ${appError.message}`);
+            if (appError.stack) {
+                console.error(appError.stack);
+            }
+        }
+        if (request.path.startsWith('/api/')) {
+            response.status(appError.statusCode).json({
+                error: true,
+                message: appError.message,
+            });
+            return;
+        }
+        response.status(appError.statusCode).send(appError.message);
+    });
+    return {
+        app,
+        services: {
+            catalogService,
+            notesService,
+            playbackService,
+        },
+    };
+}
+function getNumericRouteParam(value) {
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed)) {
+        throw new app_error_1.AppError('Invalid route parameter', 400);
+    }
+    return parsed;
+}
+function getQueryValue(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function normalizeError(caughtError) {
+    if (caughtError instanceof app_error_1.AppError) {
+        return caughtError;
+    }
+    if (caughtError instanceof Error) {
+        return new app_error_1.AppError(caughtError.message, 500);
+    }
+    return new app_error_1.AppError('Internal Server Error', 500);
+}
+async function registerWebApplication(app) {
+    if (app_config_1.appConfig.isDevelopment) {
+        const { createServer } = await import('vite');
+        const vite = await createServer({
+            configFile: node_path_1.default.resolve(process.cwd(), 'vite.config.ts'),
+            server: { middlewareMode: true },
+            appType: 'custom',
+        });
+        app.use(vite.middlewares);
+        app.use(async (request, response, next) => {
+            if (request.path.startsWith('/api/')) {
+                next();
+                return;
+            }
+            try {
+                const templatePath = node_path_1.default.resolve(process.cwd(), 'web/index.html');
+                const template = await promises_1.default.readFile(templatePath, 'utf8');
+                const html = await vite.transformIndexHtml(request.originalUrl, template);
+                response.status(200).set({ 'Content-Type': 'text/html' }).end(html);
+            }
+            catch (caughtError) {
+                next(caughtError);
+            }
+        });
+        return;
+    }
+    const webDistPath = node_path_1.default.resolve(process.cwd(), 'dist/web');
+    app.use(express_1.default.static(webDistPath));
+    app.use((request, response, next) => {
+        if (request.path.startsWith('/api/')) {
+            next();
+            return;
+        }
+        const indexPath = node_path_1.default.join(webDistPath, 'index.html');
+        if (!node_fs_1.default.existsSync(indexPath)) {
+            response.status(200).type('html').send('<!doctype html><html><body><div id="root"></div></body></html>');
+            return;
+        }
+        response.sendFile(indexPath);
+    });
+}

package/dist/app/server/start-server.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+exports.resolveCoursePath = resolveCoursePath;
+exports.getDefaultPort = getDefaultPort;
+const node_path_1 = __importDefault(require("node:path"));
+const open_1 = __importDefault(require("open"));
+const create_app_1 = require("./create-app");
+const app_config_1 = require("../../platform/config/app-config");
+const database_manager_1 = require("../../platform/database/database-manager");
+const logger_1 = require("../../platform/logging/logger");
+async function startServer(options) {
+    const database = new database_manager_1.DatabaseManager(options.coursePath).initialize();
+    const { app, services } = await (0, create_app_1.createCourseWatcherApp)(database);
+    (0, logger_1.log)('Scanning for video files...');
+    const scanResult = services.catalogService.scanVideos();
+    (0, logger_1.success)(`Found ${scanResult.total} videos (${scanResult.added} new, ${scanResult.existing} existing)`);
+    return new Promise((resolve, reject) => {
+        const sockets = new Set();
+        const start = (port) => {
+            const server = app.listen(port, () => {
+                const url = `http://localhost:${port}`;
+                (0, logger_1.success)(`Server running at ${url}`);
+                if (options.openBrowser) {
+                    void (0, open_1.default)(url).catch(() => undefined);
+                }
+                server.on('connection', (socket) => {
+                    sockets.add(socket);
+                    socket.on('close', () => sockets.delete(socket));
+                });
+                const shutdown = (signal) => {
+                    (0, logger_1.log)(`Shutting down... (${signal})`);
+                    for (const socket of sockets) {
+                        socket.destroy();
+                    }
+                    database.close();
+                    server.close(() => {
+                        (0, logger_1.success)('Server closed');
+                        process.exit(0);
+                    });
+                };
+                process.once('SIGINT', () => shutdown('SIGINT'));
+                process.once('SIGTERM', () => shutdown('SIGTERM'));
+                resolve({
+                    server,
+                    database,
+                });
+            });
+            server.on('error', (caughtError) => {
+                if (caughtError.code === 'EADDRINUSE' && options.allowFallback) {
+                    (0, logger_1.log)(`Port ${port} is busy, trying ${port + 1}...`);
+                    start(port + 1);
+                    return;
+                }
+                if (caughtError.code === 'EADDRINUSE') {
+                    (0, logger_1.error)(`Port ${port} is already in use`);
+                }
+                reject(caughtError);
+            });
+        };
+        start(options.port);
+    });
+}
+function resolveCoursePath(inputPath) {
+    return node_path_1.default.resolve(inputPath);
+}
+function getDefaultPort() {
+    return app_config_1.appConfig.defaultPort;
+}

package/dist/modules/catalog/catalog-mappers.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSort = normalizeSort;
+exports.toVideoSummary = toVideoSummary;
+exports.toVideoDetails = toVideoDetails;
+exports.toCatalogModule = toCatalogModule;
+exports.toCourseStats = toCourseStats;
+exports.toSearchResult = toSearchResult;
+function normalizeSort(sortBy) {
+    const allowedSorts = ['name', 'name_desc', 'date', 'date_desc'];
+    return allowedSorts.includes(sortBy) ? sortBy : 'name';
+}
+function toVideoSummary(video, moduleName = null) {
+    return {
+        id: video.id,
+        title: video.title,
+        filename: video.filename,
+        duration: video.duration,
+        position: video.position,
+        status: video.status,
+        moduleId: video.module_id,
+        moduleName,
+    };
+}
+function toVideoDetails(video, moduleName = null) {
+    return {
+        ...toVideoSummary(video, moduleName),
+        path: video.path,
+    };
+}
+function toCatalogModule(moduleRow, videos) {
+    return {
+        id: moduleRow?.id ?? null,
+        name: moduleRow?.name ?? 'Videos',
+        videos,
+    };
+}
+function toCourseStats(total, completed, inProgress) {
+    return {
+        total,
+        completed,
+        inProgress,
+        unwatched: total - completed - inProgress,
+        percentComplete: total > 0 ? Math.round((completed / total) * 100) : 0,
+    };
+}
+function toSearchResult(video, moduleName) {
+    return toVideoSummary(video, moduleName);
+}

package/dist/modules/catalog/catalog-repository.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalogRepository = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const app_config_1 = require("../../platform/config/app-config");
+class CatalogRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    scanVideos() {
+        const coursePath = this.database.getCoursePath();
+        const videos = this.findVideoFiles(coursePath);
+        let added = 0;
+        let existing = 0;
+        this.database.transaction(() => {
+            for (const video of videos) {
+                const current = this.database.get('SELECT id FROM videos WHERE path = ?', [video.path]);
+                if (current) {
+                    this.database.run('UPDATE videos SET title = ? WHERE id = ?', [video.title, current.id]);
+                    existing += 1;
+                    continue;
+                }
+                const moduleId = this.getOrCreateModule(video.modulePath, video.moduleName);
+                this.database.run(`
+            INSERT INTO videos (path, filename, title, module_id, sort_order)
+            VALUES (?, ?, ?, ?, ?)
+          `, [video.path, video.filename, video.title, moduleId, video.sortOrder]);
+                added += 1;
+            }
+        });
+        return {
+            total: videos.length,
+            added,
+            existing,
+        };
+    }
+    findVideoById(videoId) {
+        return this.database.get('SELECT * FROM videos WHERE id = ?', [videoId]);
+    }
+    findModuleName(moduleId) {
+        if (moduleId === null) {
+            return null;
+        }
+        return this.database.get('SELECT name FROM modules WHERE id = ?', [moduleId])?.name ?? null;
+    }
+    listModules() {
+        return this.database.all('SELECT * FROM modules ORDER BY sort_order, name');
+    }
+    listVideosForModule(moduleId, sortBy) {
+        const orderBy = this.getVideoOrderBy(sortBy);
+        if (moduleId === null) {
+            return this.database.all(`SELECT * FROM videos WHERE module_id IS NULL ${orderBy}`);
+        }
+        return this.database.all(`SELECT * FROM videos WHERE module_id = ? ${orderBy}`, [moduleId]);
+    }
+    searchVideos(query) {
+        const searchTerm = `%${query}%`;
+        return this.database.all(`
+        SELECT v.*, m.name AS module_name
+        FROM videos v
+        LEFT JOIN modules m ON v.module_id = m.id
+        WHERE v.title LIKE ? OR v.filename LIKE ?
+        ORDER BY v.sort_order, v.filename
+      `, [searchTerm, searchTerm]);
+    }
+    getStatsCounts() {
+        const total = this.database.get('SELECT COUNT(*) AS count FROM videos')?.count ?? 0;
+        const completed = this.database.get("SELECT COUNT(*) AS count FROM videos WHERE status = 'completed'")?.count ?? 0;
+        const inProgress = this.database.get("SELECT COUNT(*) AS count FROM videos WHERE status = 'in-progress'")?.count ?? 0;
+        return {
+            total,
+            completed,
+            inProgress,
+        };
+    }
+    listAdjacentVideoIds(video) {
+        const videos = video.module_id === null
+            ? this.database.all('SELECT id FROM videos WHERE module_id IS NULL ORDER BY sort_order, filename')
+            : this.database.all('SELECT id FROM videos WHERE module_id = ? ORDER BY sort_order, filename', [video.module_id]);
+        const currentIndex = videos.findIndex(({ id }) => id === video.id);
+        return {
+            prev: currentIndex > 0 ? videos[currentIndex - 1].id : null,
+            next: currentIndex >= 0 && currentIndex < videos.length - 1 ? videos[currentIndex + 1].id : null,
+        };
+    }
+    listQueueVideos(video) {
+        if (video.module_id === null) {
+            return this.database.all('SELECT * FROM videos WHERE module_id IS NULL ORDER BY sort_order, filename');
+        }
+        return this.database.all('SELECT * FROM videos WHERE module_id = ? ORDER BY sort_order, filename', [video.module_id]);
+    }
+    findVideoFiles(dir, relativeTo = dir) {
+        const videos = [];
+        try {
+            const entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = node_path_1.default.join(dir, entry.name);
+                if (entry.name === app_config_1.appConfig.dbFolder) {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    videos.push(...this.findVideoFiles(fullPath, relativeTo));
+                    continue;
+                }
+                if (!entry.isFile()) {
+                    continue;
+                }
+                const extension = node_path_1.default.extname(entry.name).toLowerCase();
+                if (!app_config_1.appConfig.videoExtensions.includes(extension)) {
+                    continue;
+                }
+                const relativePath = node_path_1.default.relative(relativeTo, fullPath);
+                const parts = relativePath.split(node_path_1.default.sep);
+                const moduleName = parts.length > 1 ? parts[0] : 'Root';
+                const modulePath = parts.length > 1 ? node_path_1.default.join(relativeTo, parts[0]) : relativeTo;
+                videos.push({
+                    path: fullPath,
+                    filename: entry.name,
+                    title: this.extractTitle(entry.name),
+                    moduleName,
+                    modulePath,
+                    sortOrder: this.extractSortOrder(entry.name),
+                });
+            }
+        }
+        catch {
+            return videos;
+        }
+        return videos.sort((left, right) => left.sortOrder - right.sortOrder);
+    }
+    extractTitle(filename) {
+        return node_path_1.default.basename(filename, node_path_1.default.extname(filename)).replace(/_/g, ' ').trim() || filename;
+    }
+    extractSortOrder(value) {
+        const match = value.match(/^(\d+)/);
+        return match ? Number.parseInt(match[1], 10) : 999;
+    }
+    getOrCreateModule(modulePath, moduleName) {
+        if (moduleName === 'Root') {
+            return null;
+        }
+        const existing = this.database.get('SELECT id FROM modules WHERE path = ?', [modulePath]);
+        if (existing) {
+            return existing.id;
+        }
+        const result = this.database.run('INSERT INTO modules (name, path, sort_order) VALUES (?, ?, ?)', [moduleName, modulePath, this.extractSortOrder(moduleName)]);
+        return Number(result.lastInsertRowid);
+    }
+    getVideoOrderBy(sortBy) {
+        switch (sortBy) {
+            case 'name_desc':
+                return 'ORDER BY sort_order DESC, filename DESC';
+            case 'date':
+                return 'ORDER BY created_at ASC';
+            case 'date_desc':
+                return 'ORDER BY created_at DESC';
+            case 'name':
+            default:
+                return 'ORDER BY sort_order, filename';
+        }
+    }
+}
+exports.CatalogRepository = CatalogRepository;

package/dist/modules/catalog/catalog-service.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalogService = void 0;
+const app_error_1 = require("../../platform/errors/app-error");
+const catalog_mappers_1 = require("./catalog-mappers");
+class CatalogService {
+    catalogRepository;
+    playbackService;
+    notesService;
+    constructor(catalogRepository, playbackService, notesService) {
+        this.catalogRepository = catalogRepository;
+        this.playbackService = playbackService;
+        this.notesService = notesService;
+    }
+    scanVideos() {
+        return this.catalogRepository.scanVideos();
+    }
+    getCatalog(sortBy) {
+        const currentSort = (0, catalog_mappers_1.normalizeSort)(sortBy);
+        const modules = this.catalogRepository.listModules().map((moduleRow) => (0, catalog_mappers_1.toCatalogModule)(moduleRow, this.catalogRepository
+            .listVideosForModule(moduleRow.id, currentSort)
+            .map((video) => (0, catalog_mappers_1.toVideoSummary)(video, moduleRow.name))));
+        const rootVideos = this.catalogRepository
+            .listVideosForModule(null, currentSort)
+            .map((video) => (0, catalog_mappers_1.toVideoSummary)(video, null));
+        if (rootVideos.length > 0) {
+            modules.unshift((0, catalog_mappers_1.toCatalogModule)(null, rootVideos));
+        }
+        const counts = this.catalogRepository.getStatsCounts();
+        return {
+            currentSort,
+            modules,
+            stats: (0, catalog_mappers_1.toCourseStats)(counts.total, counts.completed, counts.inProgress),
+        };
+    }
+    getStats() {
+        const counts = this.catalogRepository.getStatsCounts();
+        return (0, catalog_mappers_1.toCourseStats)(counts.total, counts.completed, counts.inProgress);
+    }
+    getPlayerPayload(videoId) {
+        const video = this.catalogRepository.findVideoById(videoId);
+        if (!video) {
+            throw new app_error_1.NotFoundError(`Video with id ${videoId}`);
+        }
+        const moduleName = this.catalogRepository.findModuleName(video.module_id);
+        return {
+            video: (0, catalog_mappers_1.toVideoDetails)(video, moduleName),
+            adjacent: this.catalogRepository.listAdjacentVideoIds(video),
+            notes: this.notesService.getNotes(videoId),
+            queue: {
+                currentId: video.id,
+                moduleName: moduleName ?? 'Videos',
+                videos: this.catalogRepository
+                    .listQueueVideos(video)
+                    .map((queueVideo) => (0, catalog_mappers_1.toVideoSummary)(queueVideo, moduleName)),
+            },
+            startPosition: this.playbackService.getPlaybackStartPosition(video),
+        };
+    }
+    searchVideos(query) {
+        if (!query) {
+            return [];
+        }
+        return this.catalogRepository
+            .searchVideos(query)
+            .map((video) => (0, catalog_mappers_1.toSearchResult)(video, video.module_name));
+    }
+    getVideoPath(videoId) {
+        const video = this.catalogRepository.findVideoById(videoId);
+        if (!video) {
+            throw new app_error_1.NotFoundError(`Video with id ${videoId}`);
+        }
+        return video.path;
+    }
+}
+exports.CatalogService = CatalogService;

package/dist/modules/notes/notes-repository.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotesRepository = void 0;
+class NotesRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    findVideo(videoId) {
+        return this.database.get('SELECT id FROM videos WHERE id = ?', [videoId]);
+    }
+    findNotes(videoId) {
+        return this.database.get('SELECT * FROM notes WHERE video_id = ?', [videoId]);
+    }
+    saveNotes(videoId, content) {
+        this.database.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]);
+    }
+}
+exports.NotesRepository = NotesRepository;

package/dist/modules/notes/notes-service.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotesService = void 0;
+const app_error_1 = require("../../platform/errors/app-error");
+class NotesService {
+    notesRepository;
+    constructor(notesRepository) {
+        this.notesRepository = notesRepository;
+    }
+    getNotes(videoId) {
+        if (!this.notesRepository.findVideo(videoId)) {
+            throw new app_error_1.NotFoundError(`Video with id ${videoId}`);
+        }
+        const notes = this.notesRepository.findNotes(videoId);
+        return {
+            videoId,
+            content: notes?.content ?? '',
+        };
+    }
+    saveNotes(videoId, content) {
+        if (!this.notesRepository.findVideo(videoId)) {
+            throw new app_error_1.NotFoundError(`Video with id ${videoId}`);
+        }
+        this.notesRepository.saveNotes(videoId, content);
+        return this.getNotes(videoId);
+    }
+}
+exports.NotesService = NotesService;