Renamed some functions to match base service and base repository.

Cleaned up some formatting.
Moved pagination back to repository service (and used base service pagination function).
Modified error handling to match base service and base repository.

.eslintrc.yml

@@ -174,7 +174,7 @@ rules:
   no-restricted-properties: error
   no-restricted-syntax: error
   no-return-assign: 'off'
-  no-return-await: error
+  no-return-await: 'off'
   no-script-url: error
   no-self-assign:
     - error

app/controllers/references-controller.js

@@ -61,11 +61,12 @@ exports.update = async function(req, res) {
     const referenceData = req.body;
 
     // Create the reference
-        try {
+    try {
         const reference = await referencesService.update(referenceData);
         if (!reference) {
             return res.status(404).send('Reference not found.');
-        } else {
+        }
+        else {
             logger.debug('Success: Updated reference with source_name ' + reference.source_name);
             return res.status(200).send(reference);
         }

app/repository/_base.repository.js

@@ -147,7 +147,6 @@ class BaseRepository extends AbstractRepository {
 
     // eslint-disable-next-line class-methods-use-this
     async save(data) {
-
         try {
             const document = new this.model(data);
             return await document.save();

app/repository/references-repository.js

@@ -1,10 +1,9 @@
 'use strict';
 
  const Reference = require('../models/reference-model');
- const { MissingParameterError, BadlyFormattedParameterError, DuplicateIdError } = require('../exceptions');
-
-class ReferenceRepository {
+ const { BadlyFormattedParameterError, DuplicateIdError, DatabaseError } = require('../exceptions');
 
+class ReferencesRepository {
     constructor(model) {
         this.model = model;
     }
@@ -49,29 +48,10 @@ class ReferenceRepository {
         aggregation.push(facet);
 
         // Retrieve the documents
-        const results = await this.model.aggregate(aggregation);
-
-        if (options.includePagination) {
-            let derivedTotalCount = 0;
-            if (results[0].totalCount.length > 0) {
-                derivedTotalCount = results[0].totalCount[0].totalCount;
-            }
-            const returnValue = {
-                pagination: {
-                    total: derivedTotalCount,
-                    offset: options.offset,
-                    limit: options.limit
-                },
-                data: results[0].documents
-            };
-            return returnValue;
-        }
-        else {
-            return results[0].documents;
-        }
+        return await this.model.aggregate(aggregation);
     }
 
-    async create(data) {
+    async save(data) {
         // Create the document
         const reference = new this.model(data);
 
@@ -83,20 +63,17 @@ class ReferenceRepository {
         catch(err) {
             if (err.name === 'MongoServerError' && err.code === 11000) {
                 // 11000 = Duplicate index
-                throw new DuplicateIdError;
-            } else {
-                console.log(`name: ${err.name} code: ${err.code}`);
-                throw err;
+                throw new DuplicateIdError({
+                    details: `Reference with source_name '${ data.source_name }' already exists.`
+                });
+            }
+            else {
+                throw new DatabaseError(err);
             }
         }
     }
 
-    async update(data) {
-        // Note: source_name is used as the key and cannot be updated
-        if (!data.source_name) {
-            throw new MissingParameterError;
-        }
-
+    async updateAndSave(data) {
         try {
             const document = await this.model.findOne({ 'source_name': data.source_name });
             if (!document) {
@@ -112,26 +89,22 @@ class ReferenceRepository {
         }
         catch(err) {
             if (err.name === 'CastError') {
-                throw new BadlyFormattedParameterError;
+                throw new BadlyFormattedParameterError({ parameterName: 'source_name' });
             }
-            else  if (err.name === 'MongoServerError' && err.code === 11000) {
-                // 11000 = Duplicate index
-                throw new DuplicateIdError;
-            } else {
-                throw err;
+            else {
+                throw new DatabaseError(err);
             }
         }
     }
 
-    async deleteBySourceName(sourceName) {
-        if (!sourceName) {
-            throw new MissingParameterError;
+    async findOneAndRemove(sourceName) {
+        try {
+            return await this.model.findOneAndRemove({ 'source_name': sourceName });
+        }
+        catch(err) {
+            throw new DatabaseError(err);
         }
-
-        const deletedReference = await this.model.findOneAndRemove({ 'source_name': sourceName });
-        return deletedReference;
     }
-
 }
 
-module.exports = new ReferenceRepository(Reference);
+module.exports = new ReferencesRepository(Reference);

app/services/_base.service.js

@@ -53,7 +53,7 @@ class BaseService extends AbstractService {
         try {
             results = await this.repository.retrieveAll(options);
         } catch (err) {
-            const databaseError = new DatabaseError(err); // Let the DatabaseError buddle up
+            const databaseError = new DatabaseError(err); // Let the DatabaseError bubble up
             if (callback) {
                 return callback(databaseError);
             }

app/services/references-service.js

@@ -1,33 +1,41 @@
 'use strict';
 
-const ReferenceRepository = require('../repository/references-repository');
+const baseService = require('./_base.service');
+const ReferencesRepository = require('../repository/references-repository');
+const { MissingParameterError } = require('../exceptions');
 
 class ReferencesService {
-
     constructor() {
-        this.repository = ReferenceRepository;
+        this.repository = ReferencesRepository;
     }
 
     async retrieveAll(options) {
-        const res = await this.repository.retrieveAll(options);
-        return res;
+        const results = await this.repository.retrieveAll(options);
+        const paginatedResults = baseService.paginate(options, results);
+
+        return paginatedResults;
     }
 
     async create(data) {
-        const res = await this.repository.create(data);
-        return res;
+        return await this.repository.save(data);
     }
 
     async update(data) {
-        const res = await this.repository.update(data);
-        return res;
+        // Note: source_name is used as the key and cannot be updated
+        if (!data.source_name) {
+            throw new MissingParameterError({ parameterName: 'source_name' });
+        }
+
+        return await this.repository.updateAndSave(data);
     }
 
     async deleteBySourceName(sourceName) {
-        const res = await this.repository.deleteBySourceName(sourceName);
-        return res;
-    }
+        if (!sourceName) {
+            throw new MissingParameterError({ parameterName: 'source_name' });
+        }
 
+        return await this.repository.findOneAndRemove(sourceName);
+    }
 }
 
-module.exports = new ReferencesService(ReferenceRepository);
+module.exports = new ReferencesService(ReferencesRepository);