karaoke-eternal 1.0.0 → 2.0.0-beta.6

package/build/server/Library/socket.js

@@ -0,0 +1,35 @@
+import Library from './Library.js';
+import { STAR_SONG, SONG_STARRED, UNSTAR_SONG, SONG_UNSTARRED, _SUCCESS } from '../../shared/actionTypes.js';
+const ACTION_HANDLERS = {
+    [STAR_SONG]: async (sock, { payload }, acknowledge) => {
+        const changes = await Library.starSong(payload.songId, sock.user.userId);
+        // success
+        acknowledge({ type: STAR_SONG + _SUCCESS });
+        // tell all clients (some users may be in multiple rooms)
+        if (changes) {
+            sock.server.emit('action', {
+                type: SONG_STARRED,
+                payload: {
+                    userId: sock.user.userId,
+                    songId: payload.songId,
+                },
+            });
+        }
+    },
+    [UNSTAR_SONG]: async (sock, { payload }, acknowledge) => {
+        const changes = await Library.unstarSong(payload.songId, sock.user.userId);
+        // success
+        acknowledge({ type: UNSTAR_SONG + _SUCCESS });
+        if (changes) {
+            // tell all clients (some users may be in multiple rooms)
+            sock.server.emit('action', {
+                type: SONG_UNSTARRED,
+                payload: {
+                    userId: sock.user.userId,
+                    songId: payload.songId,
+                },
+            });
+        }
+    },
+};
+export default ACTION_HANDLERS;

package/build/server/Media/Media.js

@@ -0,0 +1,170 @@
+import sql from 'sqlate';
+import Database from '../lib/Database.js';
+import getLogger from '../lib/Log.js';
+import Queue from '../Queue/Queue.js';
+const log = getLogger('Media');
+const { db } = Database;
+class Media {
+    /**
+     * Get media matching all search criteria
+     *
+     * @param  {Object}  filter Search criteria
+     * @return {Promise}        Object with media results
+     */
+    static async search(filter) {
+        const media = {
+            result: [],
+            entities: {},
+        };
+        const whereClause = typeof filter !== 'object'
+            ? sql `true`
+            : sql `${sql.tuple(Object.keys(filter).map(sql.column))} = ${sql.tuple(Object.values(filter))}`;
+        const query = sql `
+      SELECT
+        media.*,
+        songs.*,
+        artists.artistId, artists.name AS artist, artists.nameNorm AS artistNorm,
+        paths.pathId, paths.path
+      FROM media
+        INNER JOIN songs USING (songId)
+        INNER JOIN artists USING (artistId)
+        INNER JOIN paths USING (pathId)
+      WHERE ${whereClause}
+      ORDER BY paths.priority ASC
+    `;
+        const rows = await db.all(String(query), query.parameters);
+        for (const row of rows) {
+            media.result.push(row.mediaId);
+            media.entities[row.mediaId] = row;
+        }
+        return media;
+    }
+    /**
+     * Add media file to the library
+     *
+     * @param  {Object}  media Media object
+     * @return {Number}        New media's mediaId
+     */
+    static async add(media) {
+        if (!Number.isInteger(media.songId)
+            || !Number.isInteger(media.duration)
+            || !Number.isInteger(media.pathId)
+            || !media.relPath)
+            throw new Error('invalid media data: ' + JSON.stringify(media));
+        // currently uses an Object instead of Map
+        const query = sql `
+      INSERT INTO media ${sql.tuple(Object.keys(media).map(sql.column))}
+      VALUES ${sql.tuple(Object.values(media))}
+    `;
+        const res = await db.run(String(query), query.parameters);
+        if (!Number.isInteger(res.lastID)) {
+            throw new Error('invalid lastID from media insert');
+        }
+        return res.lastID;
+    }
+    /**
+     * Update media item
+     *
+     * @param  {Object}  media Media object
+     * @return {Promise}
+     */
+    static async update(media) {
+        const { mediaId } = media;
+        if (!Number.isInteger(mediaId)) {
+            throw new Error(`invalid mediaId: ${mediaId}`);
+        }
+        // currently uses an Object instead of Map
+        delete media.mediaId;
+        const query = sql `
+      UPDATE media
+      SET ${sql.tuple(Object.keys(media).map(sql.column))} = ${sql.tuple(Object.values(media))}
+      WHERE mediaId = ${mediaId}
+    `;
+        await db.run(String(query), query.parameters);
+    }
+    /**
+     * Removes media from the db in sqlite-friendly batches
+     *
+     * @param  {Array}  mediaIds
+     * @return {Promise}
+     */
+    static async remove(mediaIds) {
+        const batchSize = 999;
+        while (mediaIds.length) {
+            const query = sql `
+        DELETE FROM media
+        WHERE mediaId IN ${sql.in(mediaIds.splice(0, batchSize))}
+      `;
+            const res = await db.run(String(query), query.parameters);
+            log.info(`removed ${res.changes} media`);
+        }
+    }
+    /**
+     * Remove unlinked items and VACUUM
+     *
+     * @return {Promise}
+     */
+    static async cleanup() {
+        let res;
+        // remove media in nonexistent paths
+        res = await db.run(`
+      DELETE FROM media WHERE mediaId IN (
+        SELECT media.mediaId FROM media LEFT JOIN paths USING(pathId) WHERE paths.pathId IS NULL
+      )
+    `);
+        log.info(`cleanup: ${res.changes} media in nonexistent paths`);
+        // remove songs without associated media
+        res = await db.run(`
+      DELETE FROM songs WHERE songId IN (
+        SELECT songs.songId FROM songs LEFT JOIN media USING(songId) WHERE media.mediaId IS NULL
+      )
+    `);
+        log.info(`cleanup: ${res.changes} songs with no associated media`);
+        // remove stars for nonexistent songs
+        res = await db.run(`
+      DELETE FROM songStars WHERE songId IN (
+        SELECT songStars.songId FROM songStars LEFT JOIN songs USING(songId) WHERE songs.songId IS NULL
+      )
+    `);
+        log.info(`cleanup: ${res.changes} stars for nonexistent songs`);
+        // remove queue items for nonexistent songs
+        const rows = await db.all(`
+      SELECT queue.queueId FROM queue LEFT JOIN songs USING(songId) WHERE songs.songId IS NULL
+    `);
+        for (const row of rows) {
+            await Queue.remove(row.queueId);
+        }
+        log.info(`cleanup: ${rows.length} queue items for nonexistent songs`);
+        log.info('cleanup: vacuuming database');
+        await db.run('VACUUM');
+    }
+    /**
+     * Set isPreferred flag for a given media item
+     * @param  {Number}  mediaId
+     * @param  {Boolean} isPreferred
+     * @return {Promise} songId of the (un)preferred media item
+     */
+    static async setPreferred(mediaId, isPreferred) {
+        if (!Number.isInteger(mediaId) || typeof isPreferred !== 'boolean') {
+            throw new Error('invalid mediaId or value');
+        }
+        // get songId
+        const res = await Media.search({ mediaId });
+        if (!res.result.length) {
+            throw new Error(`mediaId not found: ${mediaId}`);
+        }
+        const songId = res.entities[mediaId].songId;
+        // clear any currently preferred items
+        const query = sql `
+      UPDATE media
+      SET isPreferred = 0
+      WHERE songId = ${songId}
+    `;
+        await db.run(String(query), query.parameters);
+        if (isPreferred) {
+            await Media.update({ mediaId, isPreferred: 1 });
+        }
+        return songId;
+    }
+}
+export default Media;

package/build/server/Media/fileTypes.js

@@ -0,0 +1,8 @@
+const exported = {
+    '.cdg': { mimeType: 'application/octet-stream', scan: false },
+    '.m4a': { mimeType: 'audio/mp4', requiresCDG: true },
+    '.mp3': { mimeType: 'audio/mpeg', requiresCDG: true },
+    '.mp4': { mimeType: 'video/mp4' },
+    '.zip': { mimeType: 'application/octet-stream' },
+};
+export default exported;

package/build/server/Media/ipc.js

@@ -0,0 +1,13 @@
+import Media from './Media.js';
+import { MEDIA_ADD, MEDIA_CLEANUP, MEDIA_REMOVE, MEDIA_UPDATE } from '../../shared/actionTypes.js';
+/**
+ * IPC action handlers
+ */
+export default function (io) {
+    return {
+        [MEDIA_ADD]: async ({ payload }) => Media.add(payload),
+        [MEDIA_CLEANUP]: Media.cleanup,
+        [MEDIA_REMOVE]: async ({ payload }) => Media.remove(payload),
+        [MEDIA_UPDATE]: async ({ payload }) => Media.update(payload),
+    };
+}

package/build/server/Media/router.js

@@ -0,0 +1,97 @@
+import fs from 'fs';
+import fsPromises from 'node:fs/promises';
+import { Readable } from 'stream';
+import path from 'path';
+import { unzip } from 'unzipit';
+import getLogger from '../lib/Log.js';
+import getCdgName from '../lib/getCdgName.js';
+import { getExt } from '../lib/util.js';
+import KoaRouter from '@koa/router';
+import Library from '../Library/Library.js';
+import Media from './Media.js';
+import Prefs from '../Prefs/Prefs.js';
+import Queue from '../Queue/Queue.js';
+import Rooms from '../Rooms/Rooms.js';
+import fileTypes from './fileTypes.js';
+import { LIBRARY_PUSH_SONG, QUEUE_PUSH } from '../../shared/actionTypes.js';
+const log = getLogger('Media');
+const router = new KoaRouter({ prefix: '/api/media' });
+const audioExts = Object.keys(fileTypes).filter(ext => fileTypes[ext].mimeType.startsWith('audio/'));
+// stream a media file
+router.get('/:mediaId', async (ctx) => {
+    const { type } = ctx.query;
+    if (!ctx.user.isAdmin) {
+        ctx.throw(401);
+    }
+    const mediaId = parseInt(ctx.params.mediaId, 10);
+    if (Number.isNaN(mediaId) || !type) {
+        ctx.throw(422, 'invalid mediaId or type');
+    }
+    // get media info
+    const res = await Media.search({ mediaId });
+    if (!res.result.length) {
+        ctx.throw(404, 'mediaId not found');
+    }
+    const { pathId, relPath } = res.entities[mediaId];
+    // get base path
+    const { paths } = await Prefs.get();
+    const basePath = paths.entities[pathId].path;
+    let file = path.join(basePath, relPath);
+    let buffer;
+    if (getExt(file) === '.zip') {
+        const { entries } = await unzip(new Uint8Array(await fsPromises.readFile(file)));
+        let entry;
+        if (type === 'cdg') {
+            entry = Object.keys(entries).find(f => !f.includes('/') && getExt(f) === '.cdg');
+            if (!entry)
+                ctx.throw(404, 'No .cdg file found in archive');
+        }
+        else {
+            entry = Object.keys(entries).find(f => !f.includes('/') && audioExts.includes(getExt(f)));
+            if (!entry)
+                ctx.throw(404, 'No valid audio file found in archive');
+        }
+        ctx.length = entries[entry].size;
+        ctx.type = fileTypes[getExt(entry)]?.mimeType;
+        buffer = Buffer.from(await entries[entry].arrayBuffer());
+    }
+    else {
+        if (type === 'cdg') {
+            file = await getCdgName(file);
+            if (!file)
+                ctx.throw(404, 'The .cdg file could not be found');
+        }
+        const stats = await fsPromises.stat(file);
+        ctx.length = stats.size;
+        ctx.type = fileTypes[getExt(file)]?.mimeType;
+    }
+    if (!ctx.type)
+        ctx.throw(404, `Unknown MIME type: ${file}`);
+    log.verbose('streaming %s (%sMB): %s', ctx.type, (ctx.length / 1000000).toFixed(2), file);
+    ctx.body = buffer ? Readable.from(buffer) : fs.createReadStream(file);
+});
+// set isPreferred flag
+router.all('/:mediaId/prefer', async (ctx) => {
+    if (!ctx.user.isAdmin) {
+        ctx.throw(401);
+    }
+    const mediaId = parseInt(ctx.params.mediaId, 10);
+    if (Number.isNaN(mediaId) || (ctx.request.method !== 'PUT' && ctx.request.method !== 'DELETE')) {
+        ctx.throw(422);
+    }
+    const songId = await Media.setPreferred(mediaId, ctx.request.method === 'PUT');
+    ctx.status = 200;
+    // emit (potentially) updated queues to each room
+    for (const { room, roomId } of Rooms.getActive(ctx.io)) {
+        ctx.io.to(room).emit('action', {
+            type: QUEUE_PUSH,
+            payload: await Queue.get(roomId),
+        });
+    }
+    // emit (potentially) new duration
+    ctx.io.emit('action', {
+        type: LIBRARY_PUSH_SONG,
+        payload: await Library.getSong(songId),
+    });
+});
+export default router;

package/build/server/Player/socket.js

@@ -0,0 +1,66 @@
+import Rooms from '../Rooms/Rooms.js';
+import { PLAYER_CMD_NEXT, PLAYER_CMD_OPTIONS, PLAYER_CMD_PAUSE, PLAYER_CMD_PLAY, PLAYER_CMD_REPLAY, PLAYER_CMD_VOLUME, PLAYER_REQ_NEXT, PLAYER_REQ_OPTIONS, PLAYER_REQ_PAUSE, PLAYER_REQ_PLAY, PLAYER_REQ_REPLAY, PLAYER_REQ_VOLUME, PLAYER_EMIT_STATUS, PLAYER_EMIT_LEAVE, PLAYER_STATUS, PLAYER_LEAVE, } from '../../shared/actionTypes.js';
+// ------------------------------------
+// Action Handlers
+// ------------------------------------
+const ACTION_HANDLERS = {
+    [PLAYER_REQ_OPTIONS]: async (sock, { payload }) => {
+        // @todo: emit to players only
+        sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+            type: PLAYER_CMD_OPTIONS,
+            payload,
+        });
+    },
+    [PLAYER_REQ_NEXT]: async (sock) => {
+        // @todo: emit to players only
+        sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+            type: PLAYER_CMD_NEXT,
+        });
+    },
+    [PLAYER_REQ_PAUSE]: async (sock) => {
+        // @todo: emit to players only
+        sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+            type: PLAYER_CMD_PAUSE,
+        });
+    },
+    [PLAYER_REQ_PLAY]: async (sock) => {
+        // @todo: emit to players only
+        sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+            type: PLAYER_CMD_PLAY,
+        });
+    },
+    [PLAYER_REQ_REPLAY]: async (sock, { payload }) => {
+        // @todo: emit to players only
+        sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+            type: PLAYER_CMD_REPLAY,
+            payload,
+        });
+    },
+    [PLAYER_REQ_VOLUME]: async (sock, { payload }) => {
+        // @todo: emit to players only
+        sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+            type: PLAYER_CMD_VOLUME,
+            payload,
+        });
+    },
+    [PLAYER_EMIT_STATUS]: async (sock, { payload }) => {
+        // so we can tell the room when players leave and
+        // relay last known player status on client join
+        sock._lastPlayerStatus = payload;
+        sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+            type: PLAYER_STATUS,
+            payload,
+        });
+    },
+    [PLAYER_EMIT_LEAVE]: async (sock) => {
+        sock._lastPlayerStatus = null;
+        // any players left in room?
+        if (!Rooms.isPlayerPresent(sock.server, sock.user.roomId)) {
+            sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+                type: PLAYER_LEAVE,
+                payload: { socketId: sock.id },
+            });
+        }
+    },
+};
+export default ACTION_HANDLERS;

package/build/server/Prefs/Prefs.js

@@ -0,0 +1,181 @@
+import path from 'path';
+import sql from 'sqlate';
+import crypto from 'crypto';
+import Database from '../lib/Database.js';
+import getLogger from '../lib/Log.js';
+const log = getLogger('Prefs');
+const { db } = Database;
+class Prefs {
+    /**
+     * Get all global preferences (includes media paths; excludes JWT secret key)
+     * @return {Promise<object>}
+     */
+    static async get() {
+        const prefs = {
+            paths: { result: [], entities: {} },
+            roles: { result: [], entities: {} },
+        };
+        {
+            const query = sql `
+        SELECT * FROM prefs
+        WHERE key != "jwtKey"
+      `;
+            const rows = await db.all(String(query), query.parameters);
+            // json-decode key/val pairs
+            rows.forEach((row) => {
+                prefs[row.key] = JSON.parse(row.data);
+            });
+        }
+        // include roles
+        {
+            const query = sql `
+        SELECT roleId, name
+        FROM roles
+      `;
+            const rows = await db.all(String(query), query.parameters);
+            for (const row of rows) {
+                prefs.roles.entities[row.roleId] = row;
+                prefs.roles.result.push(row.roleId);
+            }
+        }
+        // include media paths
+        {
+            const query = sql `
+        SELECT * FROM paths
+        ORDER BY priority
+      `;
+            const rows = await db.all(String(query), query.parameters);
+            for (const row of rows) {
+                const data = JSON.parse(row.data);
+                delete row.data;
+                prefs.paths.entities[row.pathId] = { ...row, ...data };
+                prefs.paths.result.push(row.pathId);
+            }
+        }
+        return prefs;
+    }
+    /**
+     * Set a global preference
+     * @param {string} key - the preference key
+     * @param {any} data - the value to be JSON-encoded
+     * @return {Promise<boolean>} Success/fail boolean
+     */
+    static async set(key, data) {
+        const query = sql `
+      REPLACE INTO prefs (key, data)
+      VALUES (${key}, ${JSON.stringify(data)})
+    `;
+        const res = await db.run(String(query), query.parameters);
+        return res.changes === 1;
+    }
+    /**
+     * Add media path
+     * @param {string} dir - an absolute path
+     * @param {object?} data - the object to be JSON-encoded
+     * @return {Promise<number>} the newly-added path's pathId
+     */
+    static async addPath(dir, data) {
+        const prefs = await Prefs.get();
+        const { result, entities } = prefs.paths;
+        // is it a subfolder of an already-added folder?
+        if (result.some(pathId => (dir + path.sep).indexOf(entities[pathId].path + path.sep) === 0)) {
+            throw new Error('Folder has already been added');
+        }
+        const fields = new Map();
+        fields.set('path', dir);
+        // priority defaults to one higher than current highest
+        fields.set('priority', result.length ? entities[result[result.length - 1]].priority + 1 : 0);
+        if (data)
+            fields.set('data', JSON.stringify(data));
+        const query = sql `
+      INSERT INTO paths ${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 (!Number.isInteger(res.lastID)) {
+            throw new Error('invalid lastID from path insert');
+        }
+        return res.lastID;
+    }
+    /**
+     * Remove a media path
+     * @param {number} pathId
+     */
+    static async removePath(pathId) {
+        const query = sql `
+      DELETE FROM paths
+      WHERE pathId = ${pathId}
+    `;
+        await db.run(String(query), query.parameters);
+    }
+    /**
+     * Set media path priorities
+     * @param {number[]} pathIds
+     */
+    static async setPathPriority(pathIds) {
+        if (!Array.isArray(pathIds)) {
+            throw new Error('pathIds must be an array');
+        }
+        const query = sql `
+      UPDATE paths
+        SET priority = CASE pathId
+          ${sql.concat(pathIds.map((pathId, i) => sql `WHEN ${pathId} THEN ${i} `))}
+        END
+      WHERE pathId IN ${sql.tuple(pathIds)}
+      `;
+        await db.run(String(query), query.parameters);
+    }
+    /**
+     * Set a path's JSON data
+     * @param {number} pathId
+     * @param {string} keyPrefix - key prefix; e.g. `prefs.`
+     * @param {object} data - key:value pair to set
+     * @todo Currently only supports one key:value pair at a time
+     */
+    static async setPathData(pathId, keyPrefix = '', data) {
+        const keys = Object.keys(data).map(key => `$.${keyPrefix}${key}`);
+        const values = Object.values(data);
+        const query = sql `
+      UPDATE paths
+      SET data = json_set(data, ${keys[0]}, json(${JSON.stringify(values[0])}))
+      WHERE pathId = ${pathId}
+    `;
+        await db.run(String(query), query.parameters);
+    }
+    /**
+     * Get JWT secret key from db
+     * @return {Promise<string>} the current or newly-generated key
+     */
+    static async getJwtKey(forceRotate = false) {
+        if (forceRotate)
+            return this.rotateJwtKey();
+        const query = sql `
+      SELECT * FROM prefs
+      WHERE key = "jwtKey"
+    `;
+        const row = await db.get(String(query), query.parameters);
+        if (row && row.data) {
+            const jwtKey = JSON.parse(row.data);
+            if (jwtKey.length === 64)
+                return jwtKey;
+        }
+        return this.rotateJwtKey();
+    }
+    /**
+     * Create or rotate JWT secret key
+     */
+    static async rotateJwtKey() {
+        const jwtKey = crypto.randomBytes(48).toString('base64'); // 64 char
+        log.info('Rotating JWT secret key (length=%s)', jwtKey.length);
+        const query = sql `
+      REPLACE INTO prefs (key, data)
+      VALUES ("jwtKey", ${JSON.stringify(jwtKey)})
+    `;
+        const res = await db.run(String(query), query.parameters);
+        if (!res.changes) {
+            throw new Error('Unable to update JWT secret key');
+        }
+        return jwtKey;
+    }
+}
+export default Prefs;