karaoke-eternal 1.0.0 → 2.0.0-beta.6

package/build/server/lib/IPCBridge.js

@@ -0,0 +1,128 @@
+import getLogger from './Log.js';
+import { _ERROR, _SUCCESS } from '../../shared/actionTypes.js';
+const log = getLogger('IPCBridge');
+const PROCESS_NAME = process.env.KES_CHILD_PROCESS || 'main';
+const isParent = typeof process.env.KES_CHILD_PROCESS === 'undefined'; // @todo
+const AsyncFunction = Object.getPrototypeOf(async function () { }).constructor;
+class IPCParent {
+    static children = new Map();
+    static handlers = {};
+    static send(action, pid) {
+        // log.debug(`${PROCESS_NAME} emit: `, action.type)
+        if (!this.children.size)
+            throw new Error('no child processes');
+        if (!pid) {
+            this.children.forEach(p => p.send(action));
+            return;
+        }
+        const subprocess = this.children.get(pid);
+        if (subprocess)
+            subprocess.send(action);
+    }
+    // 'this' keyword won't work when this method is passed as the
+    // message handler callback, so using the class name (IPCParent)
+    static handle(action) {
+        const { meta, type } = action;
+        // log.debug(`${PROCESS_NAME} rcv:`, type)
+        if (!type || typeof IPCParent.handlers[type] !== 'function') {
+            log.verbose(`${PROCESS_NAME}: no handler for action: ${type}`);
+            return;
+        }
+        // synchronous handler: just fire and forget
+        if (!(IPCParent.handlers[type] instanceof AsyncFunction)) {
+            IPCParent.handlers[type](action);
+            return;
+        }
+        // async handler: emit the result back to child
+        IPCParent.handlers[type](action).then((res) => {
+            IPCParent.send({
+                ...action,
+                type: type + _SUCCESS,
+                payload: res,
+            }, meta?.pid);
+            return;
+        }).catch((err) => {
+            IPCParent.send({
+                ...action,
+                type: type + _ERROR,
+                error: err,
+            }, meta?.pid);
+            log.error(`${PROCESS_NAME}: error in ipc action ${type}: ${err.message}`);
+        });
+    }
+    static addChild(subprocess) {
+        // parent: handle messages from child process
+        subprocess.on('message', action => this.handle(action));
+        this.children.set(subprocess.pid, subprocess);
+    }
+    static removeChild(subprocess) {
+        this.children.delete(subprocess.pid);
+    }
+    static use(obj) {
+        this.handlers = {
+            ...this.handlers,
+            ...obj,
+        };
+    }
+}
+class IPCChild {
+    static handlers = {};
+    static requests = {};
+    static reqId = 0;
+    static send(action) {
+        // console.log(`${PROCESS_NAME} emit: `, action.type)
+        process.send(action);
+    }
+    // 'this' keyword won't work when this method is passed as the
+    // message handler callback, so using the class name (IPCChild)
+    static handle(action) {
+        const { error, meta, type } = action;
+        // is this a response to a pending request?
+        if (meta?.pid === process.pid && IPCChild.requests[meta.reqId]) {
+            if (error) {
+                IPCChild.requests[meta.reqId].reject(error);
+            }
+            else {
+                IPCChild.requests[meta.reqId].resolve(action.payload);
+            }
+            // console.log(`${PROCESS_NAME} ack:`, type)
+            delete IPCChild.requests[meta.ipcId];
+            return;
+        }
+        // console.log(`${PROCESS_NAME} rcv:`, type)
+        // handle request
+        if (!type || typeof IPCChild.handlers[type] !== 'function') {
+            log.verbose(`${PROCESS_NAME}: no handler for action: ${type}`);
+            return;
+        }
+        IPCChild.handlers[type](action);
+    }
+    // used by child processes only
+    static req(action) {
+        const promise = new Promise((resolve, reject) => {
+            this.requests[++this.reqId] = { resolve, reject };
+        });
+        action = {
+            ...action,
+            meta: {
+                ...action.meta,
+                reqId: this.reqId,
+                pid: process.pid,
+            },
+        };
+        this.send(action);
+        return promise;
+    }
+    static use(obj) {
+        this.handlers = {
+            ...this.handlers,
+            ...obj,
+        };
+    }
+}
+export default isParent ? IPCParent : IPCChild;
+if (!isParent) {
+    // child: handle messages from parent process
+    // this also prevents child processes from automatically exiting
+    process.on('message', IPCChild.handle);
+}

package/build/server/lib/Log.js

@@ -0,0 +1,31 @@
+import log from 'electron-log/node.js';
+const LEVELS = [false, 'error', 'warn', 'info', 'verbose', 'debug'];
+class Logger {
+    static #instance;
+    static init(logId, cfg) {
+        // defaults
+        log.transports.console.level = 'debug';
+        log.transports.file.level = false;
+        log.transports.file.fileName = logId + '.log';
+        log.transports.file.setAppName('Karaoke Eternal Server');
+        for (const transport in cfg) {
+            for (const key in cfg[transport]) {
+                if (key === 'level')
+                    log.transports[transport].level = LEVELS[cfg[transport].level];
+                else
+                    log.transports[transport][key] = cfg[transport][key];
+            }
+        }
+        Logger.#instance = log;
+        return log;
+    }
+    static getLogger(scope = '') {
+        if (!Logger.#instance)
+            throw new Error('logger not initialized');
+        return Logger.#instance.scope(scope);
+    }
+}
+// for each process/worker to initialize their logger
+export const initLogger = Logger.init;
+// default export
+export default Logger.getLogger;

package/build/server/lib/accumulatedThrottle.js

@@ -0,0 +1,16 @@
+function accumulatedThrottle(callback, wait) {
+    let timeoutID;
+    let accumulated = [];
+    return function (...args) {
+        accumulated.push(args);
+        if (!timeoutID) {
+            timeoutID = setTimeout(function () {
+                callback(accumulated);
+                accumulated = [];
+                clearTimeout(timeoutID);
+                timeoutID = undefined;
+            }, wait);
+        }
+    };
+}
+export default accumulatedThrottle;

package/build/server/lib/bcrypt.js

@@ -0,0 +1,23 @@
+import bcrypt from 'bcrypt';
+function hash(myPlaintextPassword, saltRounds) {
+    return new Promise(function (resolve, reject) {
+        bcrypt.hash(myPlaintextPassword, saltRounds, function (err, hash) {
+            if (err)
+                return reject(err);
+            return resolve(hash);
+        });
+    });
+}
+function compare(data, hash) {
+    return new Promise(function (resolve, reject) {
+        bcrypt.compare(data, hash, function (err, matched) {
+            if (err)
+                return reject(err);
+            return resolve(matched);
+        });
+    });
+}
+export default {
+    hash,
+    compare,
+};

package/build/server/lib/cli.js

@@ -0,0 +1,131 @@
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+// Resolve package root by walking up to nearest package.json
+function findProjectRoot(startDir) {
+    let dir = startDir;
+    const root = path.parse(dir).root;
+    while (dir !== root) {
+        const pkg = path.join(dir, 'package.json');
+        if (fs.existsSync(pkg))
+            return dir;
+        dir = path.dirname(dir);
+    }
+    return startDir;
+}
+const baseDir = findProjectRoot(path.dirname(fileURLToPath(import.meta.url)));
+const env = {
+    NODE_ENV: process.env.NODE_ENV,
+    KES_CONSOLE_COLORS: process.env.KES_CONSOLE_COLORS
+        ? !['0', 'false'].includes(process.env.KES_CONSOLE_COLORS?.toLowerCase())
+        : undefined,
+    KES_PATH_ASSETS: path.join(baseDir, 'assets'),
+    KES_PATH_DATA: process.env.KES_PATH_DATA || getAppPath('Karaoke Eternal Server'),
+    KES_PATH_WEBROOT: path.join(baseDir, 'build', 'client'),
+    KES_PORT: parseInt(process.env.KES_PORT, 10) || 0,
+    KES_ROTATE_KEY: ['1', 'true'].includes(process.env.KES_ROTATE_KEY?.toLowerCase()),
+    KES_SCAN: process.env.KES_SCAN?.trim(),
+    KES_SCANNER_CONSOLE_LEVEL: parseInt(process.env.KES_SCANNER_CONSOLE_LEVEL, 10) || undefined,
+    KES_SCANNER_LOG_LEVEL: parseInt(process.env.KES_SCANNER_LOG_LEVEL, 10) || undefined,
+    KES_SERVER_CONSOLE_LEVEL: parseInt(process.env.KES_SERVER_CONSOLE_LEVEL, 10) || undefined,
+    KES_SERVER_LOG_LEVEL: parseInt(process.env.KES_SERVER_LOG_LEVEL, 10) || undefined,
+    KES_URL_PATH: process.env.KES_URL_PATH || '/',
+    // support PUID/PGID convention
+    KES_PUID: parseInt(process.env.PUID, 10) || undefined,
+    KES_PGID: parseInt(process.env.PGID, 10) || undefined,
+};
+const argv = yargs(hideBin(process.argv))
+    .version(false) // disable default handler
+    .option('data', {
+    describe: 'Absolute path of folder for database files',
+    requiresArg: true,
+    type: 'string',
+})
+    .option('p', {
+    alias: 'port',
+    describe: 'Web server port (default=0/auto)',
+    number: true,
+    requiresArg: true,
+})
+    .option('rotateKey', {
+    describe: 'Rotate the session key at startup',
+})
+    .option('scan', {
+    describe: 'Run the media scanner at startup. Accepts a comma-separated list of pathIds, or "all"',
+    type: 'string',
+})
+    .option('scannerConsoleLevel', {
+    describe: 'Media scanner console output level (default=4)',
+    number: true,
+    requiresArg: true,
+})
+    .option('scannerLogLevel', {
+    describe: 'Media scanner log file level (default=3)',
+    number: true,
+    requiresArg: true,
+})
+    .option('serverConsoleLevel', {
+    describe: 'Web server console output level (default=4)',
+    number: true,
+    requiresArg: true,
+})
+    .option('serverLogLevel', {
+    describe: 'Web server log file level (default=3)',
+    number: true,
+    requiresArg: true,
+})
+    .option('urlPath', {
+    describe: 'Web server URL base path (default=/)',
+    requiresArg: true,
+    type: 'string',
+})
+    .option('v', {
+    alias: 'version',
+    describe: 'Output the Karaoke Eternal Server version and exit',
+})
+    .usage('$0')
+    .usage('  Logging options use the following numeric levels:')
+    .usage('  0=off, 1=error, 2=warn, 3=info, 4=verbose, 5=debug')
+    .parseSync();
+if (argv.version) {
+    console.log(process.env.npm_package_version);
+    process.exit(0); // eslint-disable-line n/no-process-exit
+}
+if (argv.rotateKey) {
+    env.KES_ROTATE_KEY = true;
+}
+// CLI options take precedence over env vars
+const opts = {
+    data: 'KES_PATH_DATA',
+    port: 'KES_PORT',
+    scan: 'KES_SCAN',
+    scannerConsoleLevel: 'KES_SCANNER_CONSOLE_LEVEL',
+    scannerLogLevel: 'KES_SCANNER_LOG_LEVEL',
+    serverConsoleLevel: 'KES_SERVER_CONSOLE_LEVEL',
+    serverLogLevel: 'KES_SERVER_LOG_LEVEL',
+    urlPath: 'KES_URL_PATH',
+};
+for (const opt in opts) {
+    if (typeof argv[opt] !== 'undefined') {
+        env[opts[opt]] = argv[opt];
+        process.env[opts[opt]] = String(argv[opt]);
+    }
+}
+export default env;
+function getAppPath(appName) {
+    const home = os.homedir ? os.homedir() : process.env.HOME;
+    switch (process.platform) {
+        case 'darwin': {
+            return path.join(home, 'Library', 'Application Support', appName);
+        }
+        case 'win32': {
+            return process.env.APPDATA || path.join(home, 'AppData', 'Roaming', appName);
+        }
+        default: {
+            return process.env.XDG_CONFIG_HOME || path.join(home, '.config', appName);
+        }
+    }
+}

package/build/server/lib/getCdgName.js

@@ -0,0 +1,18 @@
+import { promisify } from 'util';
+import fs from 'fs';
+import getPerms from './getPermutations.js';
+const stat = promisify(fs.stat);
+export default async function getCdgName(file) {
+    // upper and lowercase permutations since fs may be case-sensitive
+    for (const ext of getPerms('cdg')) {
+        const cdg = file.substring(0, file.lastIndexOf('.') + 1) + ext;
+        try {
+            await stat(cdg);
+            return cdg;
+        }
+        catch {
+            // try another permutation
+        }
+    } // end for
+    return false;
+}

package/build/server/lib/getFolders.js

@@ -0,0 +1,8 @@
+import path from 'path';
+import fs from 'fs';
+import { promisify } from 'util';
+const readdir = promisify(fs.readdir);
+const getFolders = dir => readdir(dir, { withFileTypes: true })
+    .then(list => Promise.all(list.map(ent => ent.isDirectory() ? path.resolve(dir, ent.name) : null)))
+    .then(list => list.filter(f => !!f).sort());
+export default getFolders;

package/build/server/lib/getHotMiddleware.js

@@ -0,0 +1,22 @@
+// based on https://github.com/tnnevol/webpack-hot-middleware-for-koa2
+// eslint-disable-next-line n/no-unpublished-import
+import webpackHotMiddleware from 'webpack-hot-middleware';
+export default (compiler, opts) => {
+    const middleware = webpackHotMiddleware(compiler, opts);
+    return async (ctx, next) => {
+        const { end: originalEnd } = ctx.res;
+        const runNext = await new Promise((resolve) => {
+            ctx.res.end = function () {
+                originalEnd.apply(this, arguments);
+                resolve(false);
+            };
+            // call express-style middleware
+            middleware(ctx.req, ctx.res, () => {
+                resolve(true);
+            });
+        });
+        if (runNext) {
+            await next();
+        }
+    };
+};

package/build/server/lib/getIPAddress.js

@@ -0,0 +1,14 @@
+// https://gist.github.com/savokiss/96de34d4ca2d37cbb8e0799798c4c2d3
+import os from 'os';
+export default function () {
+    const interfaces = os.networkInterfaces();
+    for (const devName in interfaces) {
+        const iface = interfaces[devName];
+        for (let i = 0; i < iface.length; i++) {
+            const alias = iface[i];
+            if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.internal) {
+                return alias.address;
+            }
+        }
+    }
+}

package/build/server/lib/getPermutations.js

@@ -0,0 +1,17 @@
+// return all uppercase and lowercase permutations of str
+// based on https://stackoverflow.com/a/27995370
+function getPermutations(str) {
+    const results = [];
+    const arr = str.split('');
+    const len = Math.pow(arr.length, 2);
+    for (let i = 0; i < len; i++) {
+        for (let k = 0, j = i; k < arr.length; k++, j >>= 1) {
+            arr[k] = (j & 1) ? arr[k].toUpperCase() : arr[k].toLowerCase();
+        }
+        const combo = arr.join('');
+        results.push(combo);
+    }
+    // remove duplicates
+    return results.filter((ext, pos, self) => self.indexOf(ext) === pos);
+}
+export default getPermutations;

package/build/server/lib/getWindowsDrives.js

@@ -0,0 +1,17 @@
+import fs from 'fs';
+export default function () {
+    const possibleDrives = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('').map(letter => `${letter}:\\`);
+    const existingDrives = possibleDrives.filter((drive) => {
+        try {
+            fs.accessSync(drive, fs.constants.R_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    return existingDrives.map(drive => ({
+        path: drive,
+        label: drive.substring(0, 2),
+    }));
+}

package/build/server/lib/parseCookie.js

@@ -0,0 +1,13 @@
+// cookie helper based on
+// http://stackoverflow.com/questions/3393854/get-and-set-a-single-cookie-with-node-js-http-server
+export default function parseCookie(cookie) {
+    const list = {};
+    if (cookie) {
+        cookie.split(';')
+            .forEach((c) => {
+            const parts = c.split('=');
+            list[parts.shift().trim()] = decodeURI(parts.join('='));
+        });
+    }
+    return list;
+}

package/build/server/lib/pushQueuesAndLibrary.js

@@ -0,0 +1,22 @@
+import Library from '../Library/Library.js';
+import Queue from '../Queue/Queue.js';
+import Rooms from '../Rooms/Rooms.js';
+import { LIBRARY_PUSH, QUEUE_PUSH } from '../../shared/actionTypes.js';
+async function pushQueuesAndLibrary(io) {
+    // emit (potentially) updated queues to each room
+    // it's important that this happens before the library is pushed,
+    // otherwise queue items might reference newly non-existent songs
+    for (const { room, roomId } of Rooms.getActive(io)) {
+        io.to(room).emit('action', {
+            type: QUEUE_PUSH,
+            payload: await Queue.get(roomId),
+        });
+    }
+    // invalidate cache
+    Library.cache.version = null;
+    io.emit('action', {
+        type: LIBRARY_PUSH,
+        payload: await Library.get(),
+    });
+}
+export default pushQueuesAndLibrary;

package/{server → build/server}/lib/schemas/001-initial-schema.sql

@@ -33,23 +33,23 @@ CREATE TABLE IF NOT EXISTS "prefs" (
 
 INSERT INTO prefs (key,data) VALUES ('isFirstRun','true');
 
-CREATE TABLE IF NOT EXISTS "queue" (
-  "queueId" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-  "roomId" integer NOT NULL REFERENCES rooms(roomId) DEFERRABLE INITIALLY DEFERRED,
-  "songId" integer NOT NULL,
-  "userId" integer NOT NULL REFERENCES users(userId) DEFERRABLE INITIALLY DEFERRED
-);
-
+CREATE TABLE IF NOT EXISTS "queue" (
+  "queueId" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  "roomId" integer NOT NULL REFERENCES rooms(roomId) DEFERRABLE INITIALLY DEFERRED,
+  "songId" integer NOT NULL,
+  "userId" integer NOT NULL REFERENCES users(userId) DEFERRABLE INITIALLY DEFERRED
+);
+
 CREATE INDEX IF NOT EXISTS idxRoom ON "queue" ("roomId" ASC);
 
-CREATE TABLE IF NOT EXISTS "rooms" (
-  "roomId" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-  "name" text NOT NULL,
-  "status" text NOT NULL,
-  "password" text,
-  "dateCreated" text NOT NULL
-);
-
+CREATE TABLE IF NOT EXISTS "rooms" (
+  "roomId" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  "name" text NOT NULL,
+  "status" text NOT NULL,
+  "password" text,
+  "dateCreated" integer NOT NULL DEFAULT(0)
+);
+
 CREATE TABLE IF NOT EXISTS "songs" (
   "songId" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
   "artistId" integer NOT NULL REFERENCES artists(artistId) DEFERRABLE INITIALLY DEFERRED,
@@ -73,17 +73,17 @@ CREATE TABLE IF NOT EXISTS "songStars" (
 
 CREATE UNIQUE INDEX IF NOT EXISTS idxUserSong ON "songStars" ("userId" ASC, "songId" ASC);
 
-CREATE TABLE IF NOT EXISTS "users" (
-  "userId" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-  "username" text NOT NULL,
-  "password" text NOT NULL,
-  "name" text NOT NULL,
-  "isAdmin" integer(1) NOT NULL,
-  "image" blob,
-  "dateCreated" integer NOT NULL DEFAULT(0),
-  "dateUpdated" integer NOT NULL DEFAULT(0)
-);
-
+CREATE TABLE IF NOT EXISTS "users" (
+  "userId" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  "username" text NOT NULL,
+  "password" text NOT NULL,
+  "name" text NOT NULL,
+  "isAdmin" integer(1) NOT NULL,
+  "image" blob,
+  "dateCreated" integer NOT NULL DEFAULT(0),
+  "dateUpdated" integer NOT NULL DEFAULT(0)
+);
+
 CREATE UNIQUE INDEX IF NOT EXISTS idxUsername ON "users" ("username" ASC);
 
 -- Down

package/build/server/lib/schemas/004-paths-rooms-data.sql

@@ -0,0 +1,7 @@
+-- Up
+ALTER TABLE "paths" ADD COLUMN "data" text NOT NULL DEFAULT('{}');
+ALTER TABLE "rooms" ADD COLUMN "data" text NOT NULL DEFAULT('{}');
+
+-- Down
+ALTER TABLE "paths" DROP COLUMN "data";
+ALTER TABLE "rooms" DROP COLUMN "data";

package/build/server/lib/schemas/005-roles.sql

@@ -0,0 +1,32 @@
+-- Up
+CREATE TABLE IF NOT EXISTS "roles" (
+  "roleId" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  "name" text NOT NULL COLLATE NOCASE,
+  "data" text NOT NULL DEFAULT('{}')
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idxName ON "roles" ("name" ASC);
+
+INSERT INTO roles (name) VALUES ('admin'), ('player'), ('standard'), ('guest');
+
+ALTER TABLE users ADD COLUMN "roleId" integer NOT NULL DEFAULT 0 REFERENCES roles(roleId) DEFERRABLE INITIALLY DEFERRED;
+
+UPDATE users SET roleId = CASE
+    WHEN isAdmin = 1 THEN (SELECT roleId FROM roles WHERE name = 'admin')
+    WHEN isAdmin = 0 THEN (SELECT roleId FROM roles WHERE name = 'standard')
+    ELSE (SELECT roleId FROM roles WHERE name = 'standard')
+END;
+
+ALTER TABLE users DROP COLUMN isAdmin;
+
+-- Down
+ALTER TABLE users ADD COLUMN isAdmin integer DEFAULT 0;
+
+UPDATE users SET isAdmin = CASE
+    WHEN roleId = (SELECT roleId FROM roles WHERE name = 'admin') THEN 1
+    ELSE 0
+END;
+
+ALTER TABLE users DROP COLUMN roleId;
+
+DROP TABLE roles;

package/build/server/lib/util.js

@@ -0,0 +1,39 @@
+import path from 'path';
+import crypto from 'crypto';
+/**
+ * Gets the normalized file extension, in lowercase and including the period.
+ *
+ * @param {string} filename The filename to extract the extension from.
+ * @returns {string} The extension in lowercase with a period, or an empty string.
+ */
+export const getExt = filename => path.extname(filename).toLowerCase();
+export const parsePathIds = (str) => {
+    const nums = [];
+    // multiple ids?
+    if (str && str.includes(',')) {
+        const parts = str.split(',');
+        for (const part of parts) {
+            const n = parseInt(part.trim(), 10);
+            if (!isNaN(n))
+                nums.push(n);
+        }
+    }
+    else {
+        // single id?
+        const n = parseInt(str, 10);
+        if (!isNaN(n))
+            nums.push(n);
+    }
+    if (nums.length)
+        return nums;
+    return !!str;
+};
+export const randomChars = (length) => {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const bytes = crypto.randomBytes(length);
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += chars[bytes[i] % chars.length];
+    }
+    return result;
+};