karaoke-eternal 1.0.0

package/server/Library/Library.js

@@ -0,0 +1,340 @@
+const db = require('../lib/Database').db
+const sql = require('sqlate')
+const log = require('../lib/Log')('Library')
+const { performance } = require('perf_hooks')
+const Media = require('../Media')
+
+class Library {
+  static cache = { version: null }
+  static starCountsCache = { version: null }
+
+  /**
+  * Get artists and songs in a format suitable for sending to clients.
+  * Should not include songs or artists for which there are no media.
+  *
+  * @return {Promise} Object with artists and songs normalized
+  */
+  static async get () {
+    // already cached?
+    if (this.cache.version) return this.cache
+
+    const startTime = performance.now()
+
+    const SongIdsByArtist = {}
+    const artists = {
+      result: [],
+      entities: {}
+    }
+    const songs = {
+      result: [],
+      entities: {}
+    }
+
+    // query #1: songs
+    {
+      const query = sql`
+        SELECT duration, songs.artistId AS artistId, songs.songId AS songId, songs.title AS title,
+          MAX(isPreferred) AS isPreferred, COUNT(DISTINCT media.mediaId) AS numMedia
+        FROM media
+          INNER JOIN songs USING (songId)
+          INNER JOIN paths USING (pathId)
+        GROUP BY songId
+        ORDER BY songs.titleNorm, paths.priority ASC
+      `
+      const rows = await db.all(String(query), query.parameters)
+
+      for (const row of rows) {
+        delete row.isPreferred
+        songs.entities[row.songId] = row
+        songs.result.push(row.songId)
+
+        // add to artist's songIds
+        if (typeof SongIdsByArtist[row.artistId] === 'undefined') {
+          SongIdsByArtist[row.artistId] = []
+        }
+
+        SongIdsByArtist[row.artistId].push(row.songId)
+      }
+    }
+
+    // query #2: artists
+    {
+      const query = sql`
+        SELECT artistId, name
+        FROM artists
+        ORDER BY nameNorm ASC
+      `
+      const rows = await db.all(String(query), query.parameters)
+
+      for (const row of rows) {
+        if (SongIdsByArtist[row.artistId]) {
+          artists.result.push(row.artistId)
+          artists.entities[row.artistId] = row
+          artists.entities[row.artistId].songIds = SongIdsByArtist[row.artistId]
+        }
+      }
+    }
+
+    log.info('built library cache in %sms', (performance.now() - startTime).toFixed(3))
+
+    // cache result
+    this.cache = {
+      artists,
+      songs,
+      version: Date.now(),
+    }
+
+    return this.cache
+  }
+
+  /**
+  * Get single song in format similar to get()
+  *
+  * @param  {number}  songId
+  * @return {Promise} normalized media entries
+  */
+  static async getSong (songId) {
+    const { result, entities } = await Media.search({ songId })
+    if (!result.length) return {}
+
+    // should be in order of path priority...
+    let media = entities[result[0]]
+
+    // ...but are any preferred?
+    for (const mediaId of result) {
+      if (entities[mediaId].isPreferred) media = entities[mediaId]
+    }
+
+    return {
+      [songId]: {
+        artistId: media.artistId,
+        duration: media.duration,
+        songId: media.songId,
+        title: media.title,
+        numMedia: result.length,
+      }
+    }
+  }
+
+  /**
+  * Matches or creates artist and song
+  *
+  * @param  {object}  parsed  The object returned from MetaParser
+  * @return {object}          { artistId, songId }
+  */
+  static async matchSong (parsed) {
+    const match = {}
+
+    // match artist
+    {
+      const query = sql`
+        SELECT *
+        FROM artists
+        WHERE nameNorm = ${parsed.artistNorm}
+      `
+      const row = await db.get(String(query), query.parameters)
+
+      if (row) {
+        log.debug('matched artist: %s', row.name)
+        match.artistId = row.artistId
+        match.artist = row.name
+        match.artistNorm = row.nameNorm
+      } else {
+        log.debug('new artist: %s', parsed.artist)
+
+        const fields = new Map()
+        fields.set('name', parsed.artist)
+        fields.set('nameNorm', parsed.artistNorm)
+
+        const query = sql`
+          INSERT INTO artists ${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 artistId after insert')
+        }
+
+        match.artistId = res.lastID
+        match.artist = parsed.artist
+        match.artistNorm = parsed.artistNorm
+      }
+    }
+
+    // match song title
+    {
+      const query = sql`
+        SELECT *
+        FROM songs
+        WHERE artistId = ${match.artistId} AND titleNorm = ${parsed.titleNorm}
+      `
+      const row = await db.get(String(query), query.parameters)
+
+      if (row) {
+        log.debug('matched song: %s', row.title)
+        match.songId = row.songId
+        match.title = row.title
+        match.titleNorm = row.titleNorm
+      } else {
+        log.debug('new song: %s', parsed.title)
+
+        const fields = new Map()
+        fields.set('artistId', match.artistId)
+        fields.set('title', parsed.title)
+        fields.set('titleNorm', parsed.titleNorm)
+
+        const query = sql`
+          INSERT INTO songs ${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 songId after insert')
+        }
+
+        match.songId = res.lastID
+        match.title = parsed.title
+        match.titleNorm = parsed.titleNorm
+      }
+    }
+
+    return match
+  }
+
+  /**
+  * Gets a user's starred artists and songs
+  *
+  * @param  {Number}  userId
+  * @return {Object}
+  */
+  static async getUserStars (userId) {
+    let starredArtists, starredSongs
+
+    // get starred artists
+    {
+      const query = sql`
+        SELECT artistId
+        FROM artistStars
+        WHERE userId = ${userId}
+      `
+      const rows = await db.all(String(query), query.parameters)
+
+      starredArtists = rows.map(row => row.artistId)
+    }
+
+    // get starred songs
+    {
+      const query = sql`
+        SELECT songId
+        FROM songStars
+        WHERE userId = ${userId}
+      `
+      const rows = await db.all(String(query), query.parameters)
+
+      starredSongs = rows.map(row => row.songId)
+    }
+
+    return { starredArtists, starredSongs }
+  }
+
+  /**
+  * Add a user's star to a song
+  *
+  * @param  {Number}  songId
+  * @param  {Number}  userId
+  * @return {Promise} Number of rows affected
+  */
+  static async starSong (songId, userId) {
+    const fields = new Map()
+    fields.set('songId', songId)
+    fields.set('userId', userId)
+
+    const query = sql`
+      INSERT OR IGNORE INTO songStars ${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) {
+      // invalidate cache
+      this.starCountsCache.version = null
+    }
+
+    return res.changes
+  }
+
+  /**
+  * Remove a user's star from a song
+  *
+  * @param  {Number}  songId
+  * @param  {Number}  userId
+  * @return {Promise} Number of rows affected
+  */
+  static async unstarSong (songId, userId) {
+    const query = sql`
+      DELETE FROM songStars
+      WHERE userId = ${userId} AND songId = ${songId}
+    `
+    const res = await db.run(String(query), query.parameters)
+
+    if (res.changes) {
+      // invalidate cache
+      this.starCountsCache.version = null
+    }
+
+    return res.changes
+  }
+
+  /**
+  * Gets artist and song star counts
+  *
+  * @return {Object}
+  */
+  static async getStarCounts () {
+    // already cached?
+    if (this.starCountsCache.version) return this.starCountsCache
+
+    const startTime = performance.now()
+
+    const artists = {}
+    const songs = {}
+
+    // get artist star counts
+    {
+      const query = sql`
+        SELECT artistId, COUNT(userId) AS count
+        FROM artistStars
+        GROUP BY artistId
+      `
+      const rows = await db.all(String(query), query.parameters)
+
+      rows.forEach(row => { artists[row.artistId] = row.count })
+    }
+
+    // get song star counts
+    {
+      const query = sql`
+        SELECT songId, COUNT(userId) AS count
+        FROM songStars
+        GROUP BY songId
+      `
+      const rows = await db.all(String(query), query.parameters)
+
+      rows.forEach(row => { songs[row.songId] = row.count })
+    }
+
+    log.info('built star count cache in %sms', (performance.now() - startTime).toFixed(3))
+
+    this.starCountsCache = {
+      artists,
+      songs,
+      version: Date.now(),
+    }
+
+    return this.starCountsCache
+  }
+}
+
+module.exports = Library

package/server/Library/index.js

@@ -0,0 +1,3 @@
+const Library = require('./Library')
+
+module.exports = Library

package/server/Library/ipc.js

@@ -0,0 +1,18 @@
+const Library = require('./Library')
+const throttle = require('@jcoreio/async-throttle')
+const {
+  SCANNER_WORKER_STATUS,
+  LIBRARY_MATCH_SONG,
+} = require('../../shared/actionTypes')
+
+/**
+ * IPC action handlers
+ */
+module.exports = function (io) {
+  const emit = throttle(action => io.emit('action', action), 1000)
+
+  return {
+    [LIBRARY_MATCH_SONG]: async ({ payload }) => Library.matchSong(payload),
+    [SCANNER_WORKER_STATUS]: async action => emit(action),
+  }
+}

package/server/Library/router.js

@@ -0,0 +1,27 @@
+const KoaRouter = require('koa-router')
+const router = KoaRouter({ prefix: '/api' })
+const Media = require('../Media')
+
+// lists underlying media for a given song
+router.get('/song/:songId', async (ctx, next) => {
+  // must be admin
+  if (!ctx.user.isAdmin) {
+    ctx.throw(401)
+  }
+
+  const songId = parseInt(ctx.params.songId, 10)
+
+  if (Number.isNaN(songId)) {
+    ctx.throw(401, 'Invalid songId')
+  }
+
+  const res = await Media.search({ songId })
+
+  if (!res.result.length) {
+    ctx.throw(404)
+  }
+
+  ctx.body = res
+})
+
+module.exports = router

package/server/Library/socket.js

@@ -0,0 +1,47 @@
+const Library = require('./Library')
+const {
+  STAR_SONG,
+  SONG_STARRED,
+  UNSTAR_SONG,
+  SONG_UNSTARRED,
+  _SUCCESS,
+} = require('../../shared/actionTypes')
+
+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,
+        },
+      })
+    }
+  }
+}
+
+module.exports = ACTION_HANDLERS

package/server/Media/Media.js

@@ -0,0 +1,207 @@
+const db = require('../lib/Database').db
+const sql = require('sqlate')
+const log = require('../lib/Log')('Media')
+const Queue = require('../Queue')
+
+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
+  }
+}
+
+Media.mimeTypes = {
+  mp3: 'audio/mpeg',
+  m4a: 'audio/mp4',
+  mp4: 'video/mp4',
+  cdg: 'application/octet-stream',
+}
+
+module.exports = Media

package/server/Media/index.js

@@ -0,0 +1,3 @@
+const Media = require('./Media')
+
+module.exports = Media

package/server/Media/ipc.js

@@ -0,0 +1,19 @@
+const Media = require('./Media')
+const {
+  MEDIA_ADD,
+  MEDIA_CLEANUP,
+  MEDIA_REMOVE,
+  MEDIA_UPDATE,
+} = require('../../shared/actionTypes')
+
+/**
+ * IPC action handlers
+ */
+module.exports = 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),
+  }
+}