Add custom metadata provider controller, update model, move to item metadata utils

server/Database.js

@@ -700,45 +700,6 @@ class Database {
     })
   }
 
-  /**
-   * Returns true if a custom provider with the given slug exists
-   * @param {string} providerSlug
-   * @return {boolean}
-   */
-  async doesCustomProviderExistWithSlug(providerSlug) {
-    const id = providerSlug.split("custom-")[1]
-
-    if (!id) {
-      return false
-    }
-
-    return !!await this.customMetadataProviderModel.findByPk(id)
-  }
-
-  /**
-   * Removes a custom metadata provider
-   * @param {string} id
-   */
-  async removeCustomMetadataProviderById(id) {
-    // destroy metadta provider
-    await this.customMetadataProviderModel.destroy({
-      where: {
-        id,
-      }
-    })
-
-    const slug = `custom-${id}`;
-
-    // fallback libraries using it to google
-    await this.libraryModel.update({
-      provider: "google",
-    }, {
-      where: {
-        provider: slug,
-      }
-    });
-  }
-
   /**
    * Clean invalid records in database
    * Series should have atleast one Book

server/controllers/CustomMetadataProviderController.js

@@ -0,0 +1,117 @@
+const Logger = require('../Logger')
+const SocketAuthority = require('../SocketAuthority')
+const Database = require('../Database')
+
+const { validateUrl } = require('../utils/index')
+
+//
+// This is a controller for routes that don't have a home yet :(
+//
+class CustomMetadataProviderController {
+  constructor() { }
+
+  /**
+   * GET: /api/custom-metadata-providers
+   *
+   * @param {import('express').Request} req
+   * @param {import('express').Response} res
+   */
+  async getAll(req, res) {
+    const providers = await Database.customMetadataProviderModel.findAll()
+
+    res.json({
+      providers
+    })
+  }
+
+  /**
+   * POST: /api/custom-metadata-providers
+   *
+   * @param {import('express').Request} req
+   * @param {import('express').Response} res
+   */
+  async create(req, res) {
+    const { name, url, mediaType, authHeaderValue } = req.body
+
+    if (!name || !url || !mediaType) {
+      return res.status(400).send('Invalid request body')
+    }
+
+    const validUrl = validateUrl(url)
+    if (!validUrl) {
+      Logger.error(`[CustomMetadataProviderController] Invalid url "${url}"`)
+      return res.status(400).send('Invalid url')
+    }
+
+    const provider = await Database.customMetadataProviderModel.create({
+      name,
+      mediaType,
+      url,
+      authHeaderValue: !authHeaderValue ? null : authHeaderValue,
+    })
+
+    // TODO: Necessary to emit to all clients?
+    SocketAuthority.emitter('custom_metadata_provider_added', provider.toClientJson())
+
+    res.json({
+      provider
+    })
+  }
+
+  /**
+   * DELETE: /api/custom-metadata-providers/:id
+   * 
+   * @param {import('express').Request} req
+   * @param {import('express').Response} res
+   */
+  async delete(req, res) {
+    const slug = `custom-${req.params.id}`
+
+    /** @type {import('../models/CustomMetadataProvider')} */
+    const provider = req.customMetadataProvider
+    const providerClientJson = provider.toClientJson()
+
+    const fallbackProvider = provider.mediaType === 'book' ? 'google' : 'itunes'
+
+    await provider.destroy()
+
+    // Libraries using this provider fallback to default provider
+    await Database.libraryModel.update({
+      provider: fallbackProvider
+    }, {
+      where: {
+        provider: slug
+      }
+    })
+
+    // TODO: Necessary to emit to all clients?
+    SocketAuthority.emitter('custom_metadata_provider_removed', providerClientJson)
+
+    res.sendStatus(200)
+  }
+
+  /**
+   * Middleware that requires admin or up
+   * 
+   * @param {import('express').Request} req 
+   * @param {import('express').Response} res 
+   * @param {import('express').NextFunction} next 
+   */
+  async middleware(req, res, next) {
+    if (!req.user.isAdminOrUp) {
+      Logger.warn(`[CustomMetadataProviderController] Non-admin user "${req.user.username}" attempted access route "${req.path}"`)
+      return res.sendStatus(403)
+    }
+
+    // If id param then add req.customMetadataProvider
+    if (req.params.id) {
+      req.customMetadataProvider = await Database.customMetadataProviderModel.findByPk(req.params.id)
+      if (!req.customMetadataProvider) {
+        return res.sendStatus(404)
+      }
+    }
+
+    next()
+  }
+}
+module.exports = new CustomMetadataProviderController()

server/controllers/LibraryController.js

@@ -33,6 +33,14 @@ class LibraryController {
       return res.status(500).send('Invalid request')
     }
 
+    // Validate that the custom provider exists if given any
+    if (newLibraryPayload.provider?.startsWith('custom-')) {
+      if (!await Database.customMetadataProviderModel.checkExistsBySlug(newLibraryPayload.provider)) {
+        Logger.error(`[LibraryController] Custom metadata provider "${newLibraryPayload.provider}" does not exist`)
+        return res.status(400).send('Custom metadata provider does not exist')
+      }
+    }
+
     // Validate folder paths exist or can be created & resolve rel paths
     //   returns 400 if a folder fails to access
     newLibraryPayload.folders = newLibraryPayload.folders.map(f => {
@@ -51,11 +59,6 @@ class LibraryController {
       }
     }
 
-    // Validate that the custom provider exists if given any
-    if (newLibraryPayload.provider && newLibraryPayload.provider.startsWith("custom-")) {
-      await Database.doesCustomProviderExistWithSlug(newLibraryPayload.provider)
-    }
-
     const library = new Library()
 
     let currentLargestDisplayOrder = await Database.libraryModel.getMaxDisplayOrder()
@@ -91,19 +94,27 @@ class LibraryController {
     })
   }
 
+  /**
+   * GET: /api/libraries/:id
+   * 
+   * @param {import('express').Request} req 
+   * @param {import('express').Response} res 
+   */
   async findOne(req, res) {
     const includeArray = (req.query.include || '').split(',')
     if (includeArray.includes('filterdata')) {
       const filterdata = await libraryFilters.getFilterData(req.library.mediaType, req.library.id)
+      const customMetadataProviders = await Database.customMetadataProviderModel.getForClientByMediaType(req.library.mediaType)
 
       return res.json({
         filterdata,
         issues: filterdata.numIssues,
         numUserPlaylists: await Database.playlistModel.getNumPlaylistsForUserAndLibrary(req.user.id, req.library.id),
+        customMetadataProviders,
         library: req.library
       })
     }
-    return res.json(req.library)
+    res.json(req.library)
   }
 
   /**
@@ -120,6 +131,14 @@ class LibraryController {
   async update(req, res) {
     const library = req.library
 
+    // Validate that the custom provider exists if given any
+    if (req.body.provider?.startsWith('custom-')) {
+      if (!await Database.customMetadataProviderModel.checkExistsBySlug(req.body.provider)) {
+        Logger.error(`[LibraryController] Custom metadata provider "${req.body.provider}" does not exist`)
+        return res.status(400).send('Custom metadata provider does not exist')
+      }
+    }
+
     // Validate new folder paths exist or can be created & resolve rel paths
     //   returns 400 if a new folder fails to access
     if (req.body.folders) {
@@ -180,11 +199,6 @@ class LibraryController {
       }
     }
 
-    // Validate that the custom provider exists if given any
-    if (req.body.provider && req.body.provider.startsWith("custom-")) {
-      await Database.doesCustomProviderExistWithSlug(req.body.provider)
-    }
-
     const hasUpdates = library.update(req.body)
     // TODO: Should check if this is an update to folder paths or name only
     if (hasUpdates) {

server/controllers/MiscController.js

@@ -717,95 +717,5 @@ class MiscController {
     const stats = await adminStats.getStatsForYear(year)
     res.json(stats)
   }
-
-  /**
-   * GET: /api/custom-metadata-providers
-   *
-   * @param {import('express').Request} req
-   * @param {import('express').Response} res
-   */
-  async getCustomMetadataProviders(req, res) {
-    const providers = await Database.customMetadataProviderModel.findAll()
-
-    res.json({
-      providers: providers.map((p) => p.toUserJson()),
-    })
-  }
-
-  /**
-   * GET: /api/custom-metadata-providers/admin
-   *
-   * @param {import('express').Request} req
-   * @param {import('express').Response} res
-   */
-  async getAdminCustomMetadataProviders(req, res) {
-    if (!req.user.isAdminOrUp) {
-      Logger.error(`[MiscController] Non-admin user "${req.user.username}" attempted to get admin custom metadata providers`)
-      return res.sendStatus(403)
-    }
-
-    const providers = await Database.customMetadataProviderModel.findAll()
-
-    res.json({
-      providers,
-    })
-  }
-
-  /**
-   * PATCH: /api/custom-metadata-providers/admin
-   *
-   * @param {import('express').Request} req
-   * @param {import('express').Response} res
-   */
-  async addCustomMetadataProviders(req, res) {
-    if (!req.user.isAdminOrUp) {
-      Logger.error(`[MiscController] Non-admin user "${req.user.username}" attempted to add admin custom metadata providers`)
-      return res.sendStatus(403)
-    }
-
-    const { name, url, apiKey } = req.body
-
-    if (!name || !url || !apiKey) {
-      return res.status(500).send(`Invalid patch data`)
-    }
-
-    const provider = await Database.customMetadataProviderModel.create({
-      name,
-      url,
-      apiKey,
-    })
-
-    SocketAuthority.adminEmitter('custom_metadata_provider_added', provider)
-
-    res.json({
-      provider,
-    })
-  }
-
-  /**
-   * DELETE: /api/custom-metadata-providers/admin/:id
-   *
-   * @param {import('express').Request} req
-   * @param {import('express').Response} res
-   */
-  async deleteCustomMetadataProviders(req, res) {
-    if (!req.user.isAdminOrUp) {
-      Logger.error(`[MiscController] Non-admin user "${req.user.username}" attempted to delete admin custom metadata providers`)
-      return res.sendStatus(403)
-    }
-
-    const { id } = req.params
-
-    if (!id) {
-      return res.status(500).send(`Invalid delete data`)
-    }
-
-    const provider = await Database.customMetadataProviderModel.findByPk(id)
-    await Database.removeCustomMetadataProviderById(id)
-
-    SocketAuthority.adminEmitter('custom_metadata_provider_removed', provider)
-
-    res.sendStatus(200)
-  }
 }
 module.exports = new MiscController()

server/controllers/SessionController.js

@@ -161,7 +161,7 @@ class SessionController {
    * @typedef batchDeleteReqBody
    * @property {string[]} sessions
    * 
-   * @param {import('express').Request<{}, {}, batchDeleteReqBody, {}} req 
+   * @param {import('express').Request<{}, {}, batchDeleteReqBody, {}>} req 
    * @param {import('express').Response} res 
    */
   async batchDelete(req, res) {

server/finders/BookFinder.js

@@ -149,6 +149,13 @@ class BookFinder {
     return books
   }
 
+  /**
+   * 
+   * @param {string} title 
+   * @param {string} author 
+   * @param {string} providerSlug 
+   * @returns {Promise<Object[]>}
+   */
   async getCustomProviderResults(title, author, providerSlug) {
     const books = await this.customProviderAdapter.search(title, author, providerSlug)
     if (this.verbose) Logger.debug(`Custom provider '${providerSlug}' Search Results: ${books.length || 0}`)
@@ -325,8 +332,8 @@ class BookFinder {
     let numFuzzySearches = 0
 
     // Custom providers are assumed to be correct
-    if (provider.startsWith("custom-")) {
-      return await this.getCustomProviderResults(title, author, provider)
+    if (provider.startsWith('custom-')) {
+      return this.getCustomProviderResults(title, author, provider)
     }
 
     if (!title)

server/models/CustomMetadataProvider.js

@@ -1,4 +1,12 @@
-const { DataTypes, Model, Sequelize } = require('sequelize')
+const { DataTypes, Model } = require('sequelize')
+
+/**
+ * @typedef ClientCustomMetadataProvider
+ * @property {UUIDV4} id
+ * @property {string} name
+ * @property {string} url
+ * @property {string} slug
+ */
 
 class CustomMetadataProvider extends Model {
   constructor(values, options) {
@@ -7,26 +15,67 @@ class CustomMetadataProvider extends Model {
     /** @type {UUIDV4} */
     this.id
     /** @type {string} */
+    this.mediaType
+    /** @type {string} */
     this.name
     /** @type {string} */
     this.url
     /** @type {string} */
-    this.apiKey
+    this.authHeaderValue
+    /** @type {Object} */
+    this.extraData
+    /** @type {Date} */
+    this.createdAt
+    /** @type {Date} */
+    this.updatedAt
   }
 
   getSlug() {
     return `custom-${this.id}`
   }
 
-  toUserJson() {
+  /**
+   * Safe for clients
+   * @returns {ClientCustomMetadataProvider}
+   */
+  toClientJson() {
     return {
-      name: this.name,
       id: this.id,
+      name: this.name,
+      mediaType: this.mediaType,
       slug: this.getSlug()
     }
   }
 
+  /**
+   * Get providers for client by media type
+   * Currently only available for "book" media type
+   * 
+   * @param {string} mediaType 
+   * @returns {Promise<ClientCustomMetadataProvider[]>}
+   */
+  static async getForClientByMediaType(mediaType) {
+    if (mediaType !== 'book') return []
+    const customMetadataProviders = await this.findAll({
+      where: {
+        mediaType
+      }
+    })
+    return customMetadataProviders.map(cmp => cmp.toClientJson())
+  }
 
+  /**
+   * Check if provider exists by slug
+   * 
+   * @param {string} providerSlug 
+   * @returns {Promise<boolean>}
+   */
+  static async checkExistsBySlug(providerSlug) {
+    const providerId = providerSlug?.split?.('custom-')[1]
+    if (!providerId) return false
+
+    return (await this.count({ where: { id: providerId } })) > 0
+  }
 
   /**
    * Initialize model
@@ -40,8 +89,10 @@ class CustomMetadataProvider extends Model {
         primaryKey: true
       },
       name: DataTypes.STRING,
+      mediaType: DataTypes.STRING,
       url: DataTypes.STRING,
-      apiKey: DataTypes.STRING,
+      authHeaderValue: DataTypes.STRING,
+      extraData: DataTypes.JSON
     }, {
       sequelize,
       modelName: 'customMetadataProvider'

server/providers/CustomProviderAdapter.js

@@ -1,32 +1,40 @@
 const Database = require('../Database')
-const axios = require("axios")
-const Logger = require("../Logger")
+const axios = require('axios')
+const Logger = require('../Logger')
 
 class CustomProviderAdapter {
-    constructor() {
-    }
+    constructor() { }
 
+    /**
+     * 
+     * @param {string} title 
+     * @param {string} author 
+     * @param {string} providerSlug 
+     * @returns {Promise<Object[]>}
+     */
     async search(title, author, providerSlug) {
-        const providerId = providerSlug.split("custom-")[1]
+        const providerId = providerSlug.split('custom-')[1]
         const provider = await Database.customMetadataProviderModel.findByPk(providerId)
 
         if (!provider) {
             throw new Error("Custom provider not found for the given id")
         }
 
-        const matches = await axios.get(`${provider.url}/search?query=${encodeURIComponent(title)}${!!author ? `&author=${encodeURIComponent(author)}` : ""}`, {
-            headers: {
-                "Authorization": provider.apiKey,
-            },
-        }).then((res) => {
-            if (!res || !res.data || !Array.isArray(res.data.matches)) return null
+        const axiosOptions = {}
+        if (provider.authHeaderValue) {
+            axiosOptions.headers = {
+                'Authorization': provider.authHeaderValue
+            }
+        }
+        const matches = await axios.get(`${provider.url}/search?query=${encodeURIComponent(title)}${!!author ? `&author=${encodeURIComponent(author)}` : ""}`, axiosOptions).then((res) => {
+            if (!res?.data || !Array.isArray(res.data.matches)) return null
             return res.data.matches
         }).catch(error => {
             Logger.error('[CustomMetadataProvider] Search error', error)
             return []
         })
 
-        if (matches === null) {
+        if (!matches) {
             throw new Error("Custom provider returned malformed response")
         }
 
@@ -46,7 +54,7 @@ class CustomProviderAdapter {
             tags,
             series,
             language,
-            duration,
+            duration
         }) => {
             return {
                 title,
@@ -60,10 +68,10 @@ class CustomProviderAdapter {
                 isbn,
                 asin,
                 genres,
-                tags: tags.join(","),
-                series: series.length ? series : null,
+                tags: tags?.join(',') || null,
+                series: series?.length ? series : null,
                 language,
-                duration,
+                duration
             }
         })
     }

server/routers/ApiRouter.js

@@ -28,6 +28,7 @@ const SearchController = require('../controllers/SearchController')
 const CacheController = require('../controllers/CacheController')
 const ToolsController = require('../controllers/ToolsController')
 const RSSFeedController = require('../controllers/RSSFeedController')
+const CustomMetadataProviderController = require('../controllers/CustomMetadataProviderController')
 const MiscController = require('../controllers/MiscController')
 
 const Author = require('../objects/entities/Author')
@@ -299,6 +300,14 @@ class ApiRouter {
     this.router.post('/feeds/series/:seriesId/open', RSSFeedController.middleware.bind(this), RSSFeedController.openRSSFeedForSeries.bind(this))
     this.router.post('/feeds/:id/close', RSSFeedController.middleware.bind(this), RSSFeedController.closeRSSFeed.bind(this))
 
+    //
+    // Custom Metadata Provider routes
+    //
+    this.router.get('/custom-metadata-providers', CustomMetadataProviderController.middleware.bind(this), CustomMetadataProviderController.getAll.bind(this))
+    this.router.post('/custom-metadata-providers', CustomMetadataProviderController.middleware.bind(this), CustomMetadataProviderController.create.bind(this))
+    this.router.delete('/custom-metadata-providers/:id', CustomMetadataProviderController.middleware.bind(this), CustomMetadataProviderController.delete.bind(this))
+
+
     //
     // Misc Routes
     //
@@ -318,10 +327,6 @@ class ApiRouter {
     this.router.patch('/auth-settings', MiscController.updateAuthSettings.bind(this))
     this.router.post('/watcher/update', MiscController.updateWatchedPath.bind(this))
     this.router.get('/stats/year/:year', MiscController.getAdminStatsForYear.bind(this))
-    this.router.get('/custom-metadata-providers', MiscController.getCustomMetadataProviders.bind(this))
-    this.router.get('/custom-metadata-providers/admin', MiscController.getAdminCustomMetadataProviders.bind(this))
-    this.router.patch('/custom-metadata-providers/admin', MiscController.addCustomMetadataProviders.bind(this))
-    this.router.delete('/custom-metadata-providers/admin/:id', MiscController.deleteCustomMetadataProviders.bind(this))
   }
 
   //