Refactored identities service for improved structure and asynchronicity

app/controllers/identities-controller.js

@@ -2,8 +2,9 @@
 
 const identitiesService = require('../services/identities-service');
 const logger = require('../lib/logger');
+const { DuplicateIdError, BadlyFormattedParameterError, InvalidQueryStringParameterError } = require('../exceptions');
 
-exports.retrieveAll = function(req, res) {
+exports.retrieveAll = async function(req, res) {
     const options = {
         offset: req.query.offset || 0,
         limit: req.query.limit || 0,
@@ -13,76 +14,75 @@ exports.retrieveAll = function(req, res) {
         includePagination: req.query.includePagination
     }
 
-    identitiesService.retrieveAll(options, function(err, results) {
-        if (err) {
-            logger.error('Failed with error: ' + err);
-            return res.status(500).send('Unable to get identities. Server error.');
+    try {
+        const results = await identitiesService.retrieveAll(options);
+        if (options.includePagination) {
+            logger.debug(`Success: Retrieved ${ results.data.length } of ${ results.pagination.total } total identities`);
         }
         else {
-            if (options.includePagination) {
-                logger.debug(`Success: Retrieved ${ results.data.length } of ${ results.pagination.total } total identities`);
-            }
-            else {
-                logger.debug(`Success: Retrieved ${ results.length } identities`);
-            }
-            return res.status(200).send(results);
-        }
-    });
+            logger.debug(`Success: Retrieved ${ results.length } identities`);
+        }
+        return res.status(200).send(results);
+    } catch (err) {
+        logger.error('Failed with error: ' + err);
+        return res.status(500).send('Unable to get identities. Server error.');
+    }
+
 };
 
-exports.retrieveById = function(req, res) {
+exports.retrieveById = async function(req, res) {
     const options = {
         versions: req.query.versions || 'latest'
     }
 
-    identitiesService.retrieveById(req.params.stixId, options, function (err, identities) {
-        if (err) {
-            if (err.message === identitiesService.errors.badlyFormattedParameter) {
-                logger.warn('Badly formatted stix id: ' + req.params.stixId);
-                return res.status(400).send('Stix id is badly formatted.');
-            }
-            else if (err.message === identitiesService.errors.invalidQueryStringParameter) {
-                logger.warn('Invalid query string: versions=' + req.query.versions);
-                return res.status(400).send('Query string parameter versions is invalid.');
-            }
-            else {
-                logger.error('Failed with error: ' + err);
-                return res.status(500).send('Unable to get identities. Server error.');
-            }
+    try {
+        const identities = await identitiesService.retrieveById(req.params.stixId, options);
+        if (identities.length === 0) {
+            return res.status(404).send('Identity not found.');
+        }
+        else {
+            logger.debug(`Success: Retrieved ${ identities.length } identities with id ${ req.params.stixId }`);
+            return res.status(200).send(identities);
+        }
+    } catch (err) {
+        if (err instanceof BadlyFormattedParameterError) {
+            logger.warn('Badly formatted stix id: ' + req.params.stixId);
+            return res.status(400).send('Stix id is badly formatted.');
+        }
+        else if (err instanceof InvalidQueryStringParameterError) {
+            logger.warn('Invalid query string: versions=' + req.query.versions);
+            return res.status(400).send('Query string parameter versions is invalid.');
         }
         else {
-            if (identities.length === 0) {
-                return res.status(404).send('Identity not found.');
-            }
-            else {
-                logger.debug(`Success: Retrieved ${ identities.length } identities with id ${ req.params.stixId }`);
-                return res.status(200).send(identities);
-            }
-        }
-    });
+            logger.error('Failed with error: ' + err);
+            return res.status(500).send('Unable to get identities. Server error.');
+        }
+    }
+
 };
 
-exports.retrieveVersionById = function(req, res) {
-    identitiesService.retrieveVersionById(req.params.stixId, req.params.modified, function (err, identity) {
-        if (err) {
-            if (err.message === identitiesService.errors.badlyFormattedParameter) {
-                logger.warn('Badly formatted stix id: ' + req.params.stixId);
-                return res.status(400).send('Stix id is badly formatted.');
-            }
-            else {
-                logger.error('Failed with error: ' + err);
-                return res.status(500).send('Unable to get identity. Server error.');
-            }
-        } else {
-            if (!identity) {
-                return res.status(404).send('Identity not found.');
-            }
-            else {
-                logger.debug(`Success: Retrieved identity with id ${identity.id}`);
-                return res.status(200).send(identity);
-            }
-        }
-    });
+exports.retrieveVersionById = async function(req, res) {
+
+    try {
+        const identity = await identitiesService.retrieveVersionById(req.params.stixId, req.params.modified);
+        if (!identity) {
+            return res.status(404).send('Identity not found.');
+        }
+        else {
+            logger.debug(`Success: Retrieved identity with id ${identity.id}`);
+            return res.status(200).send(identity);
+        }
+    } catch (err) {
+        if (err instanceof BadlyFormattedParameterError) {
+            logger.warn('Badly formatted stix id: ' + req.params.stixId);
+            return res.status(400).send('Stix id is badly formatted.');
+        }
+        else {
+            logger.error('Failed with error: ' + err);
+            return res.status(500).send('Unable to get identity. Server error.');
+        }
+    } 
+
 };
 
 exports.create = async function(req, res) {
@@ -100,7 +100,7 @@ exports.create = async function(req, res) {
         return res.status(201).send(identity);
     }
     catch(err) {
-        if (err.message === identitiesService.errors.duplicateId) {
+        if (err instanceof DuplicateIdError) {
             logger.warn("Duplicate stix.id and stix.modified");
             return res.status(409).send('Unable to create identity. Duplicate stix.id and stix.modified properties.');
         }
@@ -111,58 +111,54 @@ exports.create = async function(req, res) {
     }
 };
 
-exports.updateFull = function(req, res) {
+exports.updateFull = async function(req, res) {
     // Get the data from the request
     const identityData = req.body;
 
     // Create the identity
-    identitiesService.updateFull(req.params.stixId, req.params.modified, identityData, function(err, identity) {
-        if (err) {
-            logger.error("Failed with error: " + err);
-            return res.status(500).send("Unable to update identity. Server error.");
+    try {
+        const identity = await identitiesService.updateFull(req.params.stixId, req.params.modified, identityData);
+        if (!identity) {
+            return res.status(404).send('Identity not found.');
+        } else {
+            logger.debug("Success: Updated identity with id " + identity.stix.id);
+            return res.status(200).send(identity);
         }
-        else {
-            if (!identity) {
-                return res.status(404).send('Identity not found.');
-            } else {
-                logger.debug("Success: Updated identity with id " + identity.stix.id);
-                return res.status(200).send(identity);
-            }
-        }
-    });
+    } catch (err) {
+        logger.error("Failed with error: " + err);
+        return res.status(500).send("Unable to update identity. Server error.");
+    }
 };
 
-exports.deleteVersionById = function(req, res) {
-    identitiesService.deleteVersionById(req.params.stixId, req.params.modified, function (err, identity) {
-        if (err) {
-            logger.error('Delete identity failed. ' + err);
-            return res.status(500).send('Unable to delete identity. Server error.');
+exports.deleteVersionById = async function(req, res) {
+
+    try {
+        const identity = await identitiesService.deleteVersionById(req.params.stixId, req.params.modified);
+        if (!identity) {
+            return res.status(404).send('Identity not found.');
+        } else {
+            logger.debug("Success: Deleted identity with id " + identity.stix.id);
+            return res.status(204).end();
         }
-        else {
-            if (!identity) {
-                return res.status(404).send('Identity not found.');
-            } else {
-                logger.debug("Success: Deleted identity with id " + identity.stix.id);
-                return res.status(204).end();
-            }
-        }
-    });
+    } catch (err) {
+        logger.error('Delete identity failed. ' + err);
+        return res.status(500).send('Unable to delete identity. Server error.');
+    }
 };
 
-exports.deleteById = function(req, res) {
-    identitiesService.deleteById(req.params.stixId, function (err, identities) {
-        if (err) {
-            logger.error('Delete identity failed. ' + err);
-            return res.status(500).send('Unable to identity identity. Server error.');
+exports.deleteById = async function(req, res) {
+
+    try {
+        const identities = await identitiesService.deleteById(req.params.stixId);
+        if (identities.deletedCount === 0) {
+            return res.status(404).send('Identity not found.');
         }
         else {
-            if (identities.deletedCount === 0) {
-                return res.status(404).send('Identity not found.');
-            }
-            else {
-                logger.debug(`Success: Deleted identity with id ${ req.params.stixId }`);
-                return res.status(204).end();
-            }
-        }
-    });
+            logger.debug(`Success: Deleted identity with id ${ req.params.stixId }`);
+            return res.status(204).end();
+        }
+    } catch (err) {
+        logger.error('Delete identity failed. ' + err);
+        return res.status(500).send('Unable to identity identity. Server error.');
+    }
 };

app/repository/identities-repository.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const BaseRepository = require('./_base.repository');
+const Identity = require('../models/identity-model');
+
+class IdentitiesRepository extends BaseRepository { }
+
+module.exports = new IdentitiesRepository(Identity);

app/services/_base.service.js

@@ -84,15 +84,13 @@ class BaseService extends AbstractService {
                 return callback(identityError);
             }
             throw identityError;
-
         }
 
         const paginatedResults = BaseService.paginate(options, results);
         if (callback) {
             return callback(null, paginatedResults);
         }
         return paginatedResults;
-
     }
 
     async retrieveById(stixId, options, callback) {
@@ -200,7 +198,6 @@ class BaseService extends AbstractService {
             const document = await this.repository.retrieveOneByVersion(stixId, modified);
 
             if (!document) {
-                console.log('** NOT FOUND');
                 if (callback) {
                     return callback(null, null);
                 }