feat: Allow empty params in csv file

backend/src/core/errors/template.errors.ts

@@ -1,7 +1,7 @@
 export class MissingTemplateKeysError extends Error {
   public readonly missingKeys: string[]
   constructor(missingKeys: string[]) {
-    super(`Template contains keys [${missingKeys}] that are not present in uploaded recipient list.`)
+    super(`The attribute(s) { ${missingKeys} } are not present in uploaded recipient list.`)
     this.missingKeys = missingKeys
     Object.setPrototypeOf(this, new.target.prototype) // restore prototype chain
     Error.captureStackTrace(this)
@@ -22,4 +22,12 @@ export class TemplateError extends Error {
     Object.setPrototypeOf(this, new.target.prototype) // restore prototype chain
     Error.captureStackTrace(this)
   }
+}
+
+export class InvalidRecipientError extends Error {
+  constructor() {
+    super('There are invalid recipient(s) in the uploaded recipient list.')
+    Object.setPrototypeOf(this, new.target.prototype) // restore prototype chain
+    Error.captureStackTrace(this)
+  }
 }

backend/src/core/services/template.service.ts

@@ -64,18 +64,21 @@ const parseTemplate = (templateBody: string, params?: { [key: string]: string })
               throw new TemplateError(`Invalid characters in param named {{${key}}}. Only alphanumeric characters allowed.`)
             }
 
+            // add key regardless, note that this is also returned in lowercase
+            variables.push(key)
+
+            // if no params continue with the loop
+            if (!params) return
+
             // if params provided == attempt to carry out templating
-            if (params) {
-              if (dict[key]) {
-                const templated = dict[key]
-                tokens.push(templated)
-              } else {
-                throw new TemplateError(`Param ${templateObject.c} not found`)
-              }
+            if (dict[key]) {
+              const templated = dict[key]
+              tokens.push(templated)
+              return
             }
 
-            // add key regardless, note that this is also returned in lowercase
-            variables.push(key)
+            // recipient key must have param
+            if (key === 'recipient') throw new TemplateError(`Param ${templateObject.c} not found`)
 
           } else { // I have not found an edge case that trips this yet
             logger.error(`Templating error: templateObject.c of ${templateObject} is undefined.`)

backend/src/email/routes/email.routes.ts

@@ -10,7 +10,7 @@ import {
   testHydration,
   extractS3Key,
 } from '@core/services'
-import { populateEmailTemplate, upsertEmailTemplate, getEmailStats } from '@email/services'
+import { populateEmailTemplate, upsertEmailTemplate, getEmailStats, hasInvalidEmailRecipient } from '@email/services'
 import {
   uploadStartHandler,
   sendCampaign,
@@ -25,6 +25,7 @@ import {
   HydrationError,
   RecipientColumnMissing,
   TemplateError,
+  InvalidRecipientError,
 } from '@core/errors'
 import { isSuperSet } from '@core/utils'
 import logger from '@core/logger'
@@ -257,6 +258,8 @@ const uploadCompleteHandler = async (req: Request, res: Response, next: NextFunc
         templateParams: emailTemplate.params,
       })
 
+      if (hasInvalidEmailRecipient(records)) throw new InvalidRecipientError()
+
       const recipientCount: number = records.length
       // START populate template
       // TODO: is actually populate message logs
@@ -272,7 +275,8 @@ const uploadCompleteHandler = async (req: Request, res: Response, next: NextFunc
       throw err
     }
   } catch (err) {
-    if (err instanceof RecipientColumnMissing || err instanceof MissingTemplateKeysError) {
+    if (err instanceof RecipientColumnMissing || err instanceof MissingTemplateKeysError 
+      || err instanceof InvalidRecipientError) {
       return res.status(400).json({ message: err.message })
     }
     return next(err)

backend/src/email/services/email.service.ts

@@ -1,12 +1,11 @@
 import { chunk } from 'lodash'
+import validator from 'validator'
 import { Campaign, JobQueue } from '@core/models'
 import { EmailMessage, EmailTemplate, EmailOp } from '@email/models'
 import logger from '@core/logger'
 import { CampaignStats } from '@core/interfaces'
 import { getStatsFromTable } from '@core/services'
 
-
-
 const upsertEmailTemplate = async ({ subject, body, campaignId }: {subject: string; body: string; campaignId: number}): Promise<EmailTemplate> => {
   let transaction
   try {
@@ -97,6 +96,10 @@ const getEmailStats = async (campaignId: number): Promise<CampaignStats> => {
 
   const stats = await getStatsFromTable(EmailMessage, campaignId) 
   return { error: stats.error, unsent: stats.unsent, sent: stats.sent, status: job.status }
-} 
+}
+
+const hasInvalidEmailRecipient = (records: MessageBulkInsertInterface[]): boolean => {
+  return records.some((record) => !validator.isEmail(record.recipient))
+}
 
-export { populateEmailTemplate, upsertEmailTemplate, getEmailStats }
+export { populateEmailTemplate, upsertEmailTemplate, getEmailStats, hasInvalidEmailRecipient }

backend/src/sms/routes/sms.routes.ts

@@ -10,7 +10,7 @@ import {
   testHydration,
   extractS3Key,
 } from '@core/services'
-import { populateSmsTemplate, upsertSmsTemplate, getSmsStats } from '@sms/services'
+import { populateSmsTemplate, upsertSmsTemplate, getSmsStats, hasInvalidSmsRecipient } from '@sms/services'
 import {
   uploadStartHandler,
   sendCampaign,
@@ -23,6 +23,7 @@ import {
   HydrationError,
   RecipientColumnMissing,
   TemplateError,
+  InvalidRecipientError,
 } from '@core/errors'
 import { isSuperSet } from '@core/utils'
 import { storeCredentials, getCampaignDetails, previewFirstMessage } from '@sms/middlewares'
@@ -260,6 +261,8 @@ const uploadCompleteHandler = async (req: Request, res: Response, next: NextFunc
         templateParams: smsTemplate.params,
       })
 
+      if (hasInvalidSmsRecipient(records)) throw new InvalidRecipientError()
+
       const recipientCount: number = records.length
       // START populate template
       // TODO: is actually populate message logs
@@ -275,7 +278,8 @@ const uploadCompleteHandler = async (req: Request, res: Response, next: NextFunc
       throw err
     }
   } catch (err) {
-    if (err instanceof RecipientColumnMissing || err instanceof MissingTemplateKeysError) {
+    if (err instanceof RecipientColumnMissing || err instanceof MissingTemplateKeysError 
+      || err instanceof InvalidRecipientError) {
       return res.status(400).json({ message: err.message })
     }
     return next(err)

backend/src/sms/services/sms.service.ts

@@ -96,4 +96,9 @@ const getSmsStats = async (campaignId: number): Promise<CampaignStats> => {
   return { error: stats.error, unsent: stats.unsent, sent: stats.sent, status: job.status }
 } 
 
-export { populateSmsTemplate, upsertSmsTemplate, getSmsStats }
+const hasInvalidSmsRecipient = (records: MessageBulkInsertInterface[]): boolean => {
+  const re = /^[0-9+]+$/
+  return records.some((record) => !record.recipient.match(re))
+}
+
+export { populateSmsTemplate, upsertSmsTemplate, getSmsStats, hasInvalidSmsRecipient }

worker/src/core/services/template.service.ts

@@ -58,18 +58,21 @@ const parseTemplate = (templateBody: string, params?: { [key: string]: string })
               throw new Error(`Invalid characters in param named {{${key}}}. Only alphanumeric characters allowed.`)
             }
 
+            // add key regardless, note that this is also returned in lowercase
+            variables.push(key)
+
+            // if no params continue with the loop
+            if (!params) return
+
             // if params provided == attempt to carry out templating
-            if (params) {
-              if (dict[key]) {
-                const templated = dict[key]
-                tokens.push(templated)
-              } else {
-                throw new Error(`Param ${templateObject.c} not found`)
-              }
+            if (dict[key]) {
+              const templated = dict[key]
+              tokens.push(templated)
+              return
             }
 
-            // add key regardless, note that this is also returned in lowercase
-            variables.push(key)
+            // recipient key must have param
+            if (key === 'recipient') throw new Error(`Param ${templateObject.c} not found`)
 
           } else { // I have not found an edge case that trips this yet
             logger.error(`Templating error: templateObject.c of ${templateObject} is undefined.`)