karaoke-eternal 1.0.0 → 2.0.0-beta.5

package/build/server/Prefs/router.js

@@ -0,0 +1,151 @@
+import path from 'path';
+import getLogger from '../lib/Log.js';
+import KoaRouter from '@koa/router';
+import getFolders from '../lib/getFolders.js';
+import getWindowsDrives from '../lib/getWindowsDrives.js';
+import Prefs from './Prefs.js';
+import Media from '../Media/Media.js';
+import pushQueuesAndLibrary from '../lib/pushQueuesAndLibrary.js';
+import Rooms from '../Rooms/Rooms.js';
+import Queue from '../Queue/Queue.js';
+import { PREFS_PATHS_CHANGED, QUEUE_PUSH } from '../../shared/actionTypes.js';
+const log = getLogger('Prefs');
+const router = new KoaRouter({ prefix: '/api/prefs' });
+// get all prefs (including media paths)
+router.get('/', async (ctx) => {
+    const prefs = await Prefs.get();
+    // must be admin or firstrun
+    if (prefs.isFirstRun || ctx.user.isAdmin) {
+        ctx.body = prefs;
+        return;
+    }
+    // non-admins only get roles
+    ctx.body = { roles: prefs.roles };
+});
+// add a media path
+router.post('/path', async (ctx) => {
+    const dir = decodeURIComponent(ctx.query.dir);
+    if (!ctx.user.isAdmin) {
+        ctx.throw(401);
+    }
+    // required
+    if (!dir) {
+        ctx.throw(422, 'Invalid path');
+    }
+    const pathId = await Prefs.addPath(dir, {
+        prefs: ctx.request.body,
+    });
+    // respond with updated prefs
+    const prefs = await Prefs.get();
+    ctx.body = prefs;
+    process.emit(PREFS_PATHS_CHANGED, prefs.paths);
+    ctx.startScanner(pathId);
+});
+// set media path preferences
+router.put('/path/:pathId', async (ctx) => {
+    if (!ctx.user.isAdmin) {
+        ctx.throw(401);
+    }
+    const pathId = parseInt(ctx.params.pathId, 10);
+    if (isNaN(pathId)) {
+        ctx.throw(422, 'Invalid pathId');
+    }
+    await Prefs.setPathData(pathId, 'prefs.', ctx.request.body);
+    // respond with updated prefs
+    const prefs = await Prefs.get();
+    ctx.body = prefs;
+    // (re)start watcher?
+    if ('isWatchingEnabled' in ctx.request.body) {
+        ;
+        process.emit(PREFS_PATHS_CHANGED, prefs.paths);
+    }
+    // need to push updated queue items?
+    if ('isVideoKeyingEnabled' in ctx.request.body) {
+        for (const { room, roomId } of Rooms.getActive(ctx.io)) {
+            ctx.io.to(room).emit('action', {
+                type: QUEUE_PUSH,
+                payload: await Queue.get(roomId),
+            });
+        }
+    }
+});
+// remove a media path
+router.delete('/path/:pathId', async (ctx) => {
+    if (!ctx.user.isAdmin) {
+        ctx.throw(401);
+    }
+    const pathId = parseInt(ctx.params.pathId, 10);
+    if (isNaN(pathId)) {
+        ctx.throw(422, 'Invalid pathId');
+    }
+    ctx.stopScanner();
+    await Prefs.removePath(pathId);
+    // respond with updated prefs
+    const prefs = await Prefs.get();
+    ctx.body = prefs;
+    process.emit(PREFS_PATHS_CHANGED, prefs.paths);
+    await Media.cleanup();
+    // no need to await
+    pushQueuesAndLibrary(ctx.io);
+});
+// scan a media path
+router.get('/path/:pathId/scan', async (ctx) => {
+    if (!ctx.user.isAdmin) {
+        ctx.throw(401);
+    }
+    const pathId = parseInt(ctx.params.pathId, 10);
+    if (isNaN(pathId)) {
+        ctx.throw(422, 'Invalid pathId');
+    }
+    ctx.status = 200;
+    ctx.startScanner(pathId);
+});
+// scan all media paths
+router.get('/paths/scan', async (ctx) => {
+    if (!ctx.user.isAdmin) {
+        ctx.throw(401);
+    }
+    ctx.status = 200;
+    ctx.startScanner(true);
+});
+// stop scanning
+router.get('/paths/scan/stop', async (ctx) => {
+    if (!ctx.user.isAdmin) {
+        ctx.throw(401);
+    }
+    ctx.status = 200;
+    ctx.stopScanner();
+});
+// get folder listing for path browser
+router.get('/path/ls', async (ctx) => {
+    if (!ctx.user.isAdmin) {
+        ctx.throw(401);
+    }
+    const dir = decodeURIComponent(ctx.query.dir);
+    // windows is a special snowflake and gets an
+    // extra top level of available drive letters
+    if (dir === '' && process.platform === 'win32') {
+        const drives = getWindowsDrives();
+        ctx.body = {
+            current: '',
+            parent: false,
+            children: drives,
+        };
+    }
+    else {
+        const current = path.resolve(dir);
+        const parent = path.resolve(dir, '../');
+        const list = await getFolders(dir);
+        log.verbose('%s listed path: %s', ctx.user.name, current);
+        ctx.body = {
+            current,
+            // if at root, windows gets a special top level
+            parent: parent === current ? (process.platform === 'win32' ? '' : false) : parent,
+            children: list.map(p => ({
+                path: p,
+                label: p.replace(current + path.sep, ''),
+            })).filter(c => !(c.label.startsWith('.') || c.label.startsWith('/.'))),
+        };
+    }
+});
+export default router;

package/build/server/Prefs/socket.js

@@ -0,0 +1,52 @@
+import getLogger from '../lib/Log.js';
+import Library from '../Library/Library.js';
+import Prefs from './Prefs.js';
+import { LIBRARY_PUSH, PREFS_PATH_SET_PRIORITY, PREFS_PUSH, PREFS_SET, _ERROR } from '../../shared/actionTypes.js';
+const log = getLogger(`server[${process.pid}]`);
+const ACTION_HANDLERS = {
+    [PREFS_SET]: async (sock, { payload }, acknowledge) => {
+        if (!sock.user.isAdmin) {
+            acknowledge({
+                type: PREFS_SET + _ERROR,
+                error: 'Unauthorized',
+            });
+        }
+        await Prefs.set(payload.key, payload.data);
+        log.info('%s (%s) set pref %s = %s', sock.user.name, sock.id, payload.key, payload.data);
+        await pushPrefs(sock);
+    },
+    [PREFS_PATH_SET_PRIORITY]: async (sock, { payload }, acknowledge) => {
+        if (!sock.user.isAdmin) {
+            acknowledge({
+                type: PREFS_PATH_SET_PRIORITY + _ERROR,
+                error: 'Unauthorized',
+            });
+        }
+        await Prefs.setPathPriority(payload);
+        log.info('%s re-prioritized media folders; pushing library to all', sock.user.name);
+        await pushPrefs(sock);
+        // invalidate cache
+        Library.cache.version = null;
+        sock.server.emit('action', {
+            type: LIBRARY_PUSH,
+            payload: await Library.get(),
+        });
+    },
+};
+// helper to push prefs to admins
+const pushPrefs = async (sock) => {
+    const admins = [];
+    for (const s of sock.server.sockets.sockets.values()) {
+        if (s.user && s.user.isAdmin) {
+            admins.push(s.id);
+            sock.server.to(s.id);
+        }
+    }
+    if (admins.length) {
+        sock.server.emit('action', {
+            type: PREFS_PUSH,
+            payload: await Prefs.get(),
+        });
+    }
+};
+export default ACTION_HANDLERS;

package/build/server/Queue/Queue.js

@@ -0,0 +1,203 @@
+import path from 'path';
+import Database from '../lib/Database.js';
+import sql from 'sqlate';
+const { db } = Database;
+class Queue {
+    /**
+     * Add a songId to a room's queue
+     *
+     * @param  {object}      roomId, songId, userId
+     * @return {Promise}
+     */
+    static async add({ roomId, songId, userId }) {
+        const fields = new Map();
+        fields.set('roomId', roomId);
+        fields.set('songId', songId);
+        fields.set('userId', userId);
+        fields.set('prevQueueId', sql `(
+      SELECT queueId
+      FROM queue
+      WHERE roomId = ${roomId} AND queueId NOT IN (
+        SELECT prevQueueId
+        FROM queue
+        WHERE prevQueueId IS NOT NULL
+      )
+    )`);
+        const query = sql `
+      INSERT INTO queue ${sql.tuple(Array.from(fields.keys()).map(sql.column))}
+      VALUES ${sql.tuple(Array.from(fields.values()))}
+    `;
+        const res = await db.run(String(query), query.parameters);
+        if (res.changes !== 1) {
+            throw new Error('Could not add song to queue');
+        }
+    }
+    /**
+     * Get queued items for a given room
+     *
+     * @param  {Number}  roomId
+     * @return {Promise}
+     */
+    static async get(roomId) {
+        const result = [];
+        const entities = {};
+        const map = new Map();
+        const pathData = new Map();
+        let curQueueId = null;
+        const query = sql `
+      SELECT queueId, songId, userId, prevQueueId,
+        media.mediaId, media.relPath, media.rgTrackGain, media.rgTrackPeak,
+        users.name AS userDisplayName, users.dateUpdated AS userDateUpdated,
+        paths.pathId, paths.data AS pathData,
+        MAX(isPreferred) AS isPreferred
+      FROM queue
+        INNER JOIN users USING(userId)
+        INNER JOIN media USING(songId)
+        INNER JOIN paths USING(pathId)
+      WHERE roomId = ${roomId}
+      GROUP BY queueId
+      ORDER BY queueId, paths.priority ASC
+    `;
+        const rows = await db.all(String(query), query.parameters);
+        for (const row of rows) {
+            if (!pathData.has(row.pathId)) {
+                pathData.set(row.pathId, JSON.parse(row.pathData));
+            }
+            const pathPrefs = pathData.get(row.pathId)?.prefs;
+            entities[row.queueId] = row;
+            entities[row.queueId].mediaType = this.getType(row.relPath);
+            entities[row.queueId].isVideoKeyingEnabled = !!pathPrefs?.isVideoKeyingEnabled;
+            // don't send over the wire
+            delete entities[row.queueId].relPath;
+            delete entities[row.queueId].isPreferred;
+            delete entities[row.queueId].pathData;
+            if (row.prevQueueId === null) {
+                // found the first item
+                result.push(row.queueId);
+                curQueueId = row.queueId;
+            }
+            else {
+                // map indexed by prevQueueId
+                map.set(row.prevQueueId, row.queueId);
+            }
+        }
+        while (result.length < rows.length) {
+            // get the item whose prevQueueId references the current one
+            const nextQueueId = entities[map.get(curQueueId)].queueId;
+            result.push(nextQueueId);
+            curQueueId = nextQueueId;
+        }
+        return { result, entities };
+    }
+    /**
+     * Move a queue item
+     * @param  {object}      prevQueueId, queueId, roomId
+     * @return {Promise}     undefined
+     */
+    static async move({ prevQueueId, queueId, roomId }) {
+        if (queueId === prevQueueId) {
+            throw new Error('Invalid prevQueueId');
+        }
+        if (prevQueueId === -1)
+            prevQueueId = null;
+        const query = sql `
+      UPDATE queue
+      SET prevQueueId = CASE
+        WHEN queueId = newChild THEN ${queueId}
+        WHEN queueId = curChild AND curParent IS NOT NULL AND newChild IS NOT NULL THEN curParent
+        WHEN queueId = ${queueId} THEN ${prevQueueId}
+        ELSE queue.prevQueueId
+      END
+      FROM (SELECT
+        (
+          SELECT prevQueueId
+          FROM queue
+          WHERE queueId = ${queueId}
+        ) AS curParent,
+        (
+          SELECT queueId
+          FROM queue
+          WHERE prevQueueId = ${queueId}
+        ) AS curChild,
+        (
+          SELECT queueId
+          FROM queue
+          WHERE queueId != ${queueId}
+            AND prevQueueId ${prevQueueId === null ? sql `IS NULL` : sql `= ${prevQueueId}`}
+            AND roomId = ${roomId}
+        ) AS newChild
+      )
+      WHERE roomId = ${roomId}
+    `;
+        await db.run(String(query), query.parameters);
+    }
+    /**
+     * Delete a queue item
+     *
+     * We could DELETE first and get the deleted item's prevQueueId using
+     * RETURNING, but the DELETE and UPDATE need to be wrapped in a transaction
+     * (so the prevQueueId foreign key check is deferred). Also, v0.9 betas didn't
+     * have prevQueueId DEFERRABLE, and so will still error at DELETE (do we care?)
+     *
+     * @param  {object}      queueId, userId
+     * @return {Promise}     undefined
+     */
+    static async remove(queueId) {
+        // close the soon-to-be gap first
+        const updateQuery = sql `
+      UPDATE queue
+      SET prevQueueId = curParent
+      FROM (
+        SELECT
+          (
+            SELECT prevQueueId
+            FROM queue
+            WHERE queueId = ${queueId}
+          ) AS curParent,
+          (
+            SELECT queueId
+            FROM queue
+            WHERE prevQueueId = ${queueId}
+          ) AS curChild
+      )
+      WHERE queueId = curChild
+    `;
+        await db.run(String(updateQuery), updateQuery.parameters);
+        // delete item
+        const deleteQuery = sql `
+      DELETE FROM queue
+      WHERE queueId = ${queueId}
+    `;
+        const deleteRes = await db.run(String(deleteQuery), deleteQuery.parameters);
+        if (!deleteRes.changes) {
+            throw new Error(`Could not remove queueId: ${queueId}`);
+        }
+    }
+    /**
+     * Check if user owns queue item(s)
+     * @param  {number} userId
+     * @param  {number|number[]} queueId
+     * @return {boolean}
+     */
+    static async isOwner(userId, queueId) {
+        const ids = Array.isArray(queueId) ? queueId : [queueId];
+        if (ids.length === 0)
+            return false;
+        const query = sql `
+      SELECT COUNT(*) AS count
+      FROM queue
+      WHERE userId = ${userId} AND queueId IN ${sql.tuple(ids)}
+    `;
+        const res = await db.get(String(query), query.parameters);
+        return res.count === ids.length;
+    }
+    /**
+     * Get media type from file extension
+     * @param  {string} file filename
+     * @return {string}      player component
+     */
+    static getType(file) {
+        return /\.mp4/i.test(path.extname(file)) ? 'mp4' : 'cdg';
+    }
+}
+export default Queue;

package/build/server/Queue/socket.js

@@ -0,0 +1,83 @@
+import Queue from './Queue.js';
+import Rooms from '../Rooms/Rooms.js';
+import { QUEUE_ADD, QUEUE_MOVE, QUEUE_REMOVE, QUEUE_PUSH } from '../../shared/actionTypes.js';
+// ------------------------------------
+// Action Handlers
+// ------------------------------------
+const ACTION_HANDLERS = {
+    [QUEUE_ADD]: async (sock, { payload }, acknowledge) => {
+        const { songId } = payload;
+        try {
+            await Rooms.validate(sock.user.roomId, null, { validatePassword: false });
+        }
+        catch (err) {
+            return acknowledge({
+                type: QUEUE_ADD + '_ERROR',
+                error: err.message,
+            });
+        }
+        await Queue.add({
+            roomId: sock.user.roomId,
+            songId,
+            userId: sock.user.userId,
+        });
+        // success
+        acknowledge({ type: QUEUE_ADD + '_SUCCESS' });
+        // to all in room
+        sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+            type: QUEUE_PUSH,
+            payload: await Queue.get(sock.user.roomId),
+        });
+    },
+    [QUEUE_MOVE]: async (sock, { payload }, acknowledge) => {
+        const { queueId, prevQueueId } = payload;
+        try {
+            await Rooms.validate(sock.user.roomId, null, { validatePassword: false });
+        }
+        catch (err) {
+            return acknowledge({
+                type: QUEUE_MOVE + '_ERROR',
+                error: err.message,
+            });
+        }
+        if (!sock.user.isAdmin && !(await Queue.isOwner(sock.user.userId, queueId))) {
+            return acknowledge({
+                type: QUEUE_MOVE + '_ERROR',
+                error: 'Cannot move another user\'s song',
+            });
+        }
+        await Queue.move({
+            prevQueueId,
+            queueId,
+            roomId: sock.user.roomId,
+        });
+        // success
+        acknowledge({ type: QUEUE_MOVE + '_SUCCESS' });
+        // tell room
+        sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+            type: QUEUE_PUSH,
+            payload: await Queue.get(sock.user.roomId),
+        });
+    },
+    [QUEUE_REMOVE]: async (sock, { payload }, acknowledge) => {
+        const { queueId } = payload;
+        const ids = Array.isArray(queueId) ? queueId : [queueId];
+        if (!sock.user.isAdmin && !(await Queue.isOwner(sock.user.userId, ids))) {
+            return acknowledge({
+                type: QUEUE_REMOVE + '_ERROR',
+                error: 'Cannot remove another user\'s song',
+            });
+        }
+        for (const id of ids) {
+            await Queue.remove(id);
+        }
+        // success
+        acknowledge({ type: QUEUE_REMOVE + '_SUCCESS' });
+        // tell room
+        sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+            type: QUEUE_PUSH,
+            payload: await Queue.get(sock.user.roomId),
+        });
+    },
+};
+export default ACTION_HANDLERS;

package/build/server/Rooms/Rooms.js

@@ -0,0 +1,171 @@
+import bcrypt from '../lib/bcrypt.js';
+import sql from 'sqlate';
+import Database from '../lib/Database.js';
+import { ValidationError } from '../lib/Errors.js';
+const { db } = Database;
+const BCRYPT_ROUNDS = 12;
+const NAME_MIN_LENGTH = 1;
+const NAME_MAX_LENGTH = 50;
+const PASSWORD_MIN_LENGTH = 5;
+export const STATUSES = ['open', 'closed'];
+class Rooms {
+    /**
+     * Get all rooms
+     *
+     * @param  {Object}
+     * @return {Promise}
+     */
+    static async get(roomId, { status = ['open'], includePassword = false } = {}) {
+        const result = [];
+        const entities = {};
+        const whereConditions = [];
+        let whereClause = sql ``;
+        if (typeof roomId === 'number') {
+            whereConditions.push(sql `roomId = ${roomId}`);
+        }
+        if (status && status.length > 0) {
+            whereConditions.push(sql `status IN ${sql.tuple(status)}`);
+        }
+        if (whereConditions.length > 0) {
+            whereClause = sql `WHERE ${whereConditions.reduce((acc, curr, index) => {
+                if (index > 0)
+                    return sql `${acc} AND ${curr}`;
+                return curr;
+            })}`;
+        }
+        const query = sql `
+      SELECT *
+      FROM rooms
+      ${whereClause}
+      ORDER BY dateCreated DESC
+    `;
+        const res = await db.all(String(query), query.parameters);
+        res.forEach((row) => {
+            const data = JSON.parse(row.data);
+            row.prefs = data.prefs ?? {};
+            delete row.data;
+            row.hasPassword = !!row.password;
+            if (!includePassword)
+                delete row.password;
+            row.dateCreated = parseInt(row.dateCreated, 10); // v1.0 schema used 'text' column
+            result.push(row.roomId);
+            entities[row.roomId] = row;
+        });
+        return { result, entities };
+    }
+    static async set(roomId, room) {
+        const { name, password, status, prefs } = room;
+        let query;
+        if (!name || !name.trim() || name.length < NAME_MIN_LENGTH || name.length > NAME_MAX_LENGTH) {
+            throw new ValidationError(`Room name must have ${NAME_MIN_LENGTH}-${NAME_MAX_LENGTH} characters`);
+        }
+        if (password && password.length < PASSWORD_MIN_LENGTH) {
+            throw new ValidationError(`Room password must have at least ${PASSWORD_MIN_LENGTH} characters`);
+        }
+        if (!status || !STATUSES.includes(status)) {
+            throw new ValidationError('Invalid room status');
+        }
+        if (typeof roomId === 'number') {
+            const passwordSql = typeof password === 'undefined'
+                // leave unchanged
+                ? sql ``
+                // empty string unsets password
+                : sql `password = ${password === '' ? null : await bcrypt.hash(password, BCRYPT_ROUNDS)},`;
+            query = sql `
+        UPDATE rooms
+        SET name = ${name},
+            ${passwordSql}
+            status = ${status},
+            data = json_set(data, '$.prefs', json(${JSON.stringify(prefs)}))
+        WHERE roomId = ${roomId}
+      `;
+        }
+        else {
+            query = sql `
+        INSERT INTO rooms (name, password, status, dateCreated, data)
+        VALUES (
+          ${name},
+          ${typeof password === 'undefined' ? null : await bcrypt.hash(password, BCRYPT_ROUNDS)},
+          ${status},
+          ${Math.floor(Date.now() / 1000)},
+          json_set('{}', '$.prefs', json(${JSON.stringify(prefs)}))
+        )
+      `;
+        }
+        return await db.run(String(query), query.parameters);
+    }
+    /**
+     * Validate a room against optional criteria
+     *
+     * @param  {Number}    roomId
+     * @param  {[String]}  password      Room password
+     * @param  {[Object]}  opts          (bool) isOpen, (bool) validatePassword
+     * @return {Promise}                 True if validated, otherwise throws an error
+     */
+    static async validate(roomId, password, { isOpen = true, validatePassword = true, role, } = {}) {
+        const res = await Rooms.get(roomId, { includePassword: true });
+        const room = res.entities[roomId];
+        if (!room) {
+            throw new Error('Room not found');
+        }
+        if (isOpen && room.status !== 'open') {
+            throw new Error('Room is no longer open');
+        }
+        if (validatePassword && room.password) {
+            if (!password) {
+                throw new Error('Room password is required');
+            }
+            if (!(await bcrypt.compare(password, room.password))) {
+                throw new Error('Incorrect room password');
+            }
+        }
+        if (role) {
+            const query = sql `SELECT roleId FROM roles WHERE name = ${role}`;
+            const row = await db.get(String(query), query.parameters);
+            const roleId = row?.roleId;
+            if (!roleId) {
+                throw new Error('Role not found');
+            }
+            if (!room.prefs?.roles?.[roleId]?.allowNew) {
+                throw new Error(`New "${role}" accounts are not allowed in this room`);
+            }
+        }
+        return true;
+    }
+    static prefix(roomId = '') {
+        return `ROOM_ID_${roomId}`;
+    }
+    /**
+     * Utility method to list active rooms on a socket.io instance
+     *
+     * @param  {Object}  io  The socket.io instance
+     * @return {Array}       Array of objects as { room, roomId }
+     */
+    static getActive(io) {
+        const rooms = [];
+        for (const room of io.sockets.adapter.rooms.keys()) {
+            // ignore auto-generated per-user rooms
+            if (room.startsWith(Rooms.prefix())) {
+                const roomId = parseInt(room.substring(Rooms.prefix().length), 10);
+                rooms.push({ room, roomId });
+            }
+        }
+        return rooms;
+    }
+    /**
+     * Utility method to determine if a player is in a room
+     *
+     * @param  {Object}  io  The socket.io instance
+     * @param  {Object}  roomId  Room to check
+     * @return {Boolean}
+     */
+    static isPlayerPresent(io, roomId) {
+        for (const sock of io.of('/').sockets.values()) {
+            if (sock.user && sock.user.roomId === roomId && sock._lastPlayerStatus) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+export default Rooms;