refactor: migrate errors server controller to typescript

package.json

@@ -182,6 +182,7 @@
     "@types/ip": "^1.1.0",
     "@types/jest": "^26.0.9",
     "@types/json-stringify-safe": "^5.0.0",
+    "@types/mongodb": "^3.5.27",
     "@types/mongodb-uri": "^0.9.0",
     "@types/mongoose": "^5.7.36",
     "@types/node": "^14.0.13",

src/app/controllers/errors.server.controller.js → src/app/controllers/errors.server.controller.ts

@@ -1,39 +1,41 @@
-'use strict'
+import _ from 'lodash'
 
-const _ = require('lodash')
+import { IMongoError } from 'src/types/error'
 
 /**
  * Default error message if no more specific error
  * @type {String}
  */
-exports.defaultErrorMessage = 'An unexpected error happened. Please try again.'
+export const defaultErrorMessage =
+  'An unexpected error happened. Please try again.'
 
 /**
  * Private helper for getMongoErrorMessage to return Mongo error in a String
- * @param  {Object} err - MongoDB error object
+ * @param  {IMongoError} err - MongoDB error object
  * @return {String} errorString - Formatted error string
  */
-const mongoDuplicateKeyError = function (err) {
+
+const mongoDuplicateKeyError = function (err: IMongoError): string {
   let errorString = ''
-  try {
-    let fieldName = err.err.substring(
+  if (err.err) {
+    const fieldName = err.err.substring(
       err.err.lastIndexOf('.$') + 2,
       err.err.lastIndexOf('_1'),
     )
     errorString =
       fieldName.charAt(0).toUpperCase() + fieldName.slice(1) + ' already exists'
-  } catch (ex) {
+  } else {
     errorString = 'Unique field already exists'
   }
   return errorString
 }
 
 /**
  * Gets Mongo error object and returns formatted String for frontend
- * @param  {Objrct} err MongoDB error object
+ * @param  {IMongoError} err? MongoDB error object
  * @return {String} message - Error message returned to frontend
  */
-exports.getMongoErrorMessage = function (err) {
+export function getMongoErrorMessage(err?: IMongoError | string): string {
   let message = ''
   if (!err) {
     return ''
@@ -50,17 +52,19 @@ exports.getMongoErrorMessage = function (err) {
         message = 'Your form is too large to be supported by the system.'
         break
       default:
-        message = exports.defaultErrorMessage
+        message = defaultErrorMessage
     }
   } else if (!_.isEmpty(err.errors)) {
     // Prefer specific error messages to a generic one
-    let errMsgs = []
-    for (let subError in err.errors) {
+    const errMsgs = []
+    for (const subError in err.errors) {
       errMsgs.push(err.errors[subError].message)
     }
     message = errMsgs.join(', ')
   } else {
-    message = err.message
+    if (err.message) {
+      message = err.message
+    }
   }
   return message
 }

src/types/error.ts

@@ -0,0 +1,11 @@
+export interface IMongoError {
+  name?: string
+  message?: string
+  code?: number
+  errmsg?: string
+  err?: string
+  errors?: {
+    [subError: string]: { message: string }
+  }
+  [propName: string]: any
+}

tests/unit/backend/controllers/errors.server.controller.spec.js → tests/unit/backend/controllers/errors.server.controller.spec.ts

@@ -1,65 +1,62 @@
-describe('Errors Controller', () => {
-  const controller = spec(
-    'dist/backend/app/controllers/errors.server.controller',
-  )
+import {
+  defaultErrorMessage,
+  getMongoErrorMessage,
+} from 'src/app/controllers/errors.server.controller'
 
+describe('Errors Controller', () => {
   describe('getMongoErrorMessage', () => {
     it('should return blank string if no error', () => {
-      expect(controller.getMongoErrorMessage()).toEqual('')
+      expect(getMongoErrorMessage()).toEqual('')
     })
 
     it('should return string if error is string', () => {
-      let err = 'something failed'
-      expect(controller.getMongoErrorMessage(err)).toEqual(err)
+      const err = 'something failed'
+      expect(getMongoErrorMessage(err)).toEqual(err)
     })
 
     it('should call mongoDuplicateKeyError helperif error code is 11000 or 11001 (with field name)', () => {
-      let err = {
+      const err = {
         err:
           'E11000 duplicate key error index: test.so.$foo_1  dup key: { : 5.0 }',
         code: 11001,
         n: 0,
         nPrev: 1,
         ok: 1,
       }
-      let expected = 'Foo already exists'
-      expect(controller.getMongoErrorMessage(err)).toEqual(expected)
+      const expected = 'Foo already exists'
+      expect(getMongoErrorMessage(err)).toEqual(expected)
     })
 
     it('should call mongoDuplicateKeyError helper if error code is 11000 or 11001 (no error msg)', () => {
-      let err = {
+      const err = {
         code: 11000,
         n: 0,
         nPrev: 1,
         ok: 1,
       }
-      let expected = 'Unique field already exists'
-      expect(controller.getMongoErrorMessage(err)).toEqual(expected)
+      const expected = 'Unique field already exists'
+      expect(getMongoErrorMessage(err)).toEqual(expected)
     })
 
     it('should return error message for other error code', () => {
-      let err = {
+      const err = {
         code: 12,
         n: 0,
         nPrev: 1,
         ok: 1,
       }
-      expect(controller.getMongoErrorMessage(err)).toEqual(
-        controller.defaultErrorMessage,
-      )
+      expect(getMongoErrorMessage(err)).toEqual(defaultErrorMessage)
     })
 
     it('should return error message if no error code', () => {
-      let err = {
+      const err = {
         errors: {
           error1: {
             message: 'error message 1',
           },
         },
       }
-      expect(controller.getMongoErrorMessage(err)).toEqual(
-        err.errors.error1.message,
-      )
+      expect(getMongoErrorMessage(err)).toEqual(err.errors.error1.message)
     })
   })
 })