Fetchall uses promises smarter. Now the utils functions also return promises to be able to nicely chain the steps a request needs to go through. Promise all lets us wait for all items return in the map function. Without the map function would return immidiately and resolve before the map operation completed.

seasoned_api/src/request/request.js

@@ -97,22 +97,13 @@ class RequestRepository {
   }
 
   fetchAll(sort_by=undefined, sort_direction='asc', filter_param=undefined, query=undefined) {
-    if (sort_by !== undefined && ! utils.validSort(sort_by, sort_direction)) {
-      throw new Error('Invalid sort parameters')
-    } else if (filter_param !== undefined && ! utils.validFilter(filter_param)) {
-      throw new Error('Invalid filter parameter')
-    }
-
     return Promise.resolve()
+      .then(() => utils.validSort(sort_by, sort_direction))
+      .then(() => utils.validFilter(filter_param))
       .then(() => this.sortAndFilterToDbQuery(sort_by, sort_direction, filter_param, query))
       .then((dbQuery) => this.database.all(dbQuery))
       .then((rows) => Promise.all(this.mapToTmdbByType(rows)))
-      .catch((err) => { throw new Error(`err ${err}`) })
   }
-
-  //   return Promise.resolve()
-  //     .then(() => this.database.get(this.))
-  // }
 }
 
 module.exports = RequestRepository;

seasoned_api/src/request/utils.js

@@ -1,22 +1,34 @@
 // TODO : test title and date are valid matches to columns in the database
-
 const validSortParams = ['title', 'date']
-const validSortDirections = ['asc', 'desc']
+const validSortDirs = ['asc', 'desc']
 const validFilterParams = ['movie', 'show', 'seeding', 'downloading', 'paused', 'finished', 'downloaded']
 
 function validSort(by, direction) {
-   if (! validSortParams.includes(by)) {
-      return false
-   }
-   else if (! validSortDirections.includes(direction)) {
-      return false
-   }
-   
-   return true
+  return new Promise((resolve, reject) => {
+    if (by === undefined) {
+      resolve()
+    }
+
+    if (validSortParams.includes(by) && validSortDirs.includes(direction)) {
+      resolve()
+    } else {
+      reject(new Error(`invalid sort parameter, must be of: ${validSortParams} with optional sort directions: ${validSortDirs} appended with ':'`))
+    }
+  });
 }
 
 function validFilter(filter_param) {
-  return validFilterParams.includes(filter_param)
+  return new Promise((resolve, reject) => {
+     if (filter_param === undefined) {
+      resolve()
+    }
+
+    if (filter_param && validFilterParams.includes(filter_param)) {
+      resolve()
+    } else {
+      reject(new Error(`filter parameteres must be of type: ${validFilterParams}`))
+    }
+  });
 }
 
 module.exports = { validSort, validFilter }

seasoned_api/src/tmdb/tmdb.js

@@ -141,7 +141,6 @@ class TMDB {
 
 
 
-
   multiSearch(search_query, page=1) {
     const query = { query: search_query, page: page };
     const cacheKey = `${this.cacheTags.multiSearch}:${page}:${search_query}`;

seasoned_api/src/webserver/controllers/request/fetchAllRequests.js

@@ -1,26 +1,6 @@
-const configuration = require('src/config/configuration').getInstance();
-const Cache = require('src/tmdb/cache');
-const TMDB = require('src/tmdb/tmdb');
 const RequestRepository = require('src/request/request');
-const cache = new Cache();
-const tmdb = new TMDB(cache, configuration.get('tmdb', 'apiKey'));
 const request = new RequestRepository();
 
-const requestAsTmdb = (type, id) => {
-  if (type !== undefined) {
-    type = type.toLowerCase();
-
-    if (type === 'movie') {
-      return tmdb.movieInfo(id);
-    } else if (type === 'show') {
-      return tmdb.showInfo(id);
-    } else {
-      throw new Error("Unprocessable Entity: Invalid type for body parameter 'type'. Allowed values: movie|show");
-    }
-  }
-  throw new Error("tmdbType body parameter not defined. Allowed values: movie|show")
-
-}
 /**
  * Controller: Request by id with type param
  * @param {Request} req http request variable
@@ -28,17 +8,15 @@ const requestAsTmdb = (type, id) => {
  * @returns {Callback}
  */
 function requestTmdbIdController(req, res) {
-  const { filter, sort, query } = req.query;
-  let sort_by = sort_direction = undefined;
+  let { filter, sort, query } = req.query;
+  let sort_by = sort;
+  let sort_direction = undefined;
 
   if (sort !== undefined && sort.includes(':')) {
     [sort_by, sort_direction] = sort.split(':')
   }
-  // log, but disregard erroros sort param
-  // non valid sort type, throw from request.fetchAll(sort, filter)
 
   Promise.resolve()
-  // .then(() => requestAsTmdb(type, id))
   .then(() => request.fetchAll(sort_by, sort_direction, filter, query))
   .then((result) => res.send(result))
   .catch((error) => {