@futdevpro/nts-dynamo 1.7.16 → 1.7.20

package/src/_services/core/email.service.ts

@@ -2,9 +2,56 @@
 import * as FileSystem from 'fs';
 import * as Path from 'path';
 import * as NodeMailer from 'nodemailer';
+
 import { Options as MailOptions, Attachment } from 'nodemailer/lib/mailer';
 
-import { Dynamo_Error, Dynamo_Log } from '@futdevpro/fsm-dynamo';
+import { Dynamo_Array, Dynamo_Error, Dynamo_Log } from '@futdevpro/fsm-dynamo';
+
+export interface DynamoNTS_EmailServiceSettings {
+  host: string,
+  port: number,
+  email: string,
+  pass: string,
+  senderName: string,
+  rootPath: string,
+  templateComponents?: DynamoNTS_EmailTemplateComponent[],
+}
+
+export class DynamoNTS_EmailTemplateComponent {
+  name: string;
+  selector: string;
+
+  templatePath?: string;
+  template?: string;
+
+  stylePath?: string;
+  styles?: string;
+
+  headerLinks?: string = '';
+
+  properties?: string[] = [];
+  subComponentSelectors?: string[] = [];
+
+  constructor(
+    set?: DynamoNTS_EmailTemplateComponent
+  ) {    
+    if (set) {
+      Object.assign(this, set);
+    }
+  }
+}
+
+export interface DynamoNTS_SendEmailSettings<T = { [propertyKey: string]: string; }> {
+  to: string;
+  subject: string;
+  /** direct email content, if provided, this will be used */
+  content?: string;
+
+  templateComponentName: string;
+  templateProperties?: T;
+
+  attachments?: Attachment[];
+}
 
 /**
  * 
@@ -15,142 +62,119 @@ export class DynamoNTS_EmailService {
   private nmTransporter: NodeMailer.Transporter;
   private senderName: string;
   private senderNEmail: string;
-  private templates: {
-    [templateName: string]: string
+  
+  private components: DynamoNTS_EmailTemplateComponent[] = [];
+  private componentsBySelector: {
+    [selector: string]: DynamoNTS_EmailTemplateComponent
   } = {};
-  private templatePropertyKeys: {
-    [templateName: string]: string[]
+  private componentsByName: {
+    [componentName: string]: DynamoNTS_EmailTemplateComponent
   } = {};
-  private templateLoadingInProgressCounter = 0;
+
+  private readonly styleLimitWarning: number = 16;
 
   defaultErrorUserMsg = 
     `We encountered an uncought Email Service Error, ` +
     `\nplease contact the responsible development team.`;
   
   constructor (
-    set: {
-      host: string,
-      port: number,
-      email: string,
-      pass: string,
-      senderName: string,
-      rootPath: string,
-      templatePaths: {
-        [templateName: string]: string
-      },
-    }
+    set: DynamoNTS_EmailServiceSettings
   ) {
+    this.serviceName = this.constructor?.name;
+    this.senderName = set.senderName;
+    this.senderNEmail = `${set.senderName} <${set.email}>`;
+    this.nmTransporter = NodeMailer.createTransport({
+      host: set.host,
+      port: set.port,
+      auth: {
+        user: set.email,
+        pass: set.pass,
+      },
+    });
+
+    this.components = set.templateComponents ?? [];
+  }
+
+  async asyncPostConstruct(): Promise<void> {
     try {
-      this.serviceName = this.constructor?.name;
-      // console.log('\n\n\n\n\nNEW CONSTRUCT STARTED', set.email);
-      this.senderName = set.senderName;
-      this.senderNEmail = `${set.senderName} <${set.email}>`;
-      this.nmTransporter = NodeMailer.createTransport({
-        host: set.host,
-        port: set.port,
-        auth: {
-          user: set.email,
-          pass: set.pass
-        }
-      });
+      if (this.components) {
+        await Dynamo_Array.asyncForEach(
+          this.components,
+          async (component: DynamoNTS_EmailTemplateComponent): Promise<void> => {
+            await this.loadComponent(component);
+          }
+        );
 
-      if (set.templatePaths) {
-        for (let key in set.templatePaths) {
-          this.loadTemplate(key, set.rootPath, set.templatePaths[key]);
-        }
-      } else {
-        this.constructionFinished();
+        this.connectComponents();
       }
+
+      Dynamo_Log.success(`\nEmailService construction (${this.senderName}) Finished!`); 
     } catch (error) {
-      Dynamo_Log.error(`\nDynamoBEEmailService ERROR, The emailService construction failed for ${set.email}.`, new Error());
-    }
-  }
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings('asyncPostConstruct', error, 'SYSTEM'),
 
-  /**
-   * 
-   */
-  private constructionFinished(): void { 
-    Dynamo_Log.success(`\nEmailService construction (${this.senderName}) Finished!`) 
+        errorCode: 'NTS-ES0-APC0',
+        message: 
+        `\nDynamoBEEmailService ERROR, ` +
+        `\nThe emailService construction failed for ${this.serviceName}.`, 
+      });
+    }
   }
 
   /**
    * 
    * @param set 
    */
-  public async sendEmail(
-    set: {
-      to: string,
-      subject: string,
-      content?: string,
-      useTemplate?: string,
-      templateProperties?: {
-        [propertyKey: string]: string
-      },
-      attachments?: Attachment[]
-    }, 
-    issuer?: string,
+  public async sendEmail<T>(
+    set: DynamoNTS_SendEmailSettings<T>, 
+    issuer: string
   ): Promise<void> {
     try {
       let content: string;
 
       if (set.content) {
-        content = set.content
+        content = set.content; 
+
       } else {
-        if (!set.useTemplate) {
+        if (!set.templateComponentName) {
           throw new Dynamo_Error({ 
             ...this._getDefaultErrorSettings(
               'sendEmail',
-              new Error(`No content setting passsed to emailSending!`),
+              new Error(
+                `No email template component is given!`
+              ),
               issuer
             ),
 
-            errorCode: 'NTS-ES4-101',
+            errorCode: 'NTS-ES0-SE1',
           });
         }
 
-        if (!this.templates[set.useTemplate]) {
+        if (!this.componentsByName[set.templateComponentName]) {
           throw new Dynamo_Error({ 
             ...this._getDefaultErrorSettings(
               'sendEmail',
-              new Error(`No email template found with this parameter! (${set.useTemplate})`),
+              new Error(
+                `No email template component found with this name! (${set.templateComponentName})`
+              ),
               issuer
             ),
 
-            errorCode: 'NTS-ES4-102',
+            errorCode: 'NTS-ES0-SE2',
+            additionalContent: {
+              availableComponenets: Object.keys(this.componentsByName),
+            },
           });
         }
 
-        content = this.templates[set.useTemplate];
-
-        if (0 < this.templatePropertyKeys[set.useTemplate].length) {
-          if (!set.templateProperties) {
-            let props = '';
-            this.templatePropertyKeys[set.useTemplate].forEach((key: string, index: number) => {
-              props += `${key}${index != this.templatePropertyKeys[set.useTemplate].length - 1 ? ', ' : ''}`;
-            });
-            Dynamo_Log.error('\nDynamoBEEmailService ERROR: INVALID sendEmail settings', set);
-            
-            throw new Dynamo_Error({ 
-              ...this._getDefaultErrorSettings(
-                'sendEmail', 
-                new Error(`TemplateProperties missing! properties needed: ${props}`), 
-                issuer
-              ),
-
-              errorCode: 'NTS-ES4-103',
-            });
-          }
-          this.templatePropertyKeys[set.useTemplate].forEach((propertyKey: string) => {
-            if (!set.templateProperties[propertyKey]) {
-              Dynamo_Log.error(`TemplateProperty missing! (${propertyKey})`);
-            }
-            const reg = new RegExp(`{{${propertyKey}}}`, 'g')
-            content = content.replace(reg, set.templateProperties[propertyKey]);
-          });
-        }
+        content = this.compileTemplateComponent(
+          set.templateComponentName, 
+          set.templateProperties, 
+          issuer
+        );
       }
 
-      let mailOptions: MailOptions = {
+      const mailOptions: MailOptions = {
         from: this.senderNEmail,
         to: set.to,
         subject: set.subject,
@@ -158,8 +182,8 @@ export class DynamoNTS_EmailService {
         attachments: set.attachments,
       };
 
-      await new Promise<void>((resolve, reject) => { 
-        this.nmTransporter.sendMail(mailOptions, (error, info) => { 
+      await new Promise<void>((resolve, reject): void => { 
+        this.nmTransporter.sendMail(mailOptions, (error): void => { 
           if (error) {
             reject(error);
           } else {
@@ -168,55 +192,419 @@ export class DynamoNTS_EmailService {
         });
       });
     } catch (error) {
-      if (error?.includes?.('all recipients were rejected')) {
+      if ((error as Error).message?.includes?.('all recipients were rejected')) {
         throw new Dynamo_Error({
           ...this._getDefaultErrorSettings('sendEmail', error, issuer),
 
-          errorCode: 'NTS-ES4-104',
-          userMessage: `Can't send mail to ${set.to}`,
-        })
+          errorCode: 'NTS-ES0-SE4',
+          userMessage: `Can't send mail to ${set.to}!`,
+          message: `sendEmail failed to ${set.to}`,
+        });
+
       } else {
         throw new Dynamo_Error({ 
           ...this._getDefaultErrorSettings('sendEmail', error, issuer),
 
-          errorCode: 'NTS-ES4-100',
-          message: `SendEmail failed!`,
+          errorCode: 'NTS-ES0-SE0',
+          message: `sendEmail failed to ${set.to}`,
         });
       }
     }
   }
 
-  /**
-   * 
-   * @param templateName 
-   * @param rootPath 
-   * @param templatePath 
-   * @returns 
-   */
-  private async loadTemplate(templateName: string, rootPath: string, templatePath: string): Promise<void> {
+  private compileTemplateComponent<T>(
+    componentName: string, 
+    componentProperties:T, 
+    issuer: string
+  ): string {
     try {
-      this.templateLoadingInProgressCounter++;
-      return new Promise<void>((resolve, reject) => {
-        templatePath = Path.join(rootPath, templatePath);
-        FileSystem.readFile(templatePath, 'utf8' , (err, template) => {
-          if (err) {
-            Dynamo_Log.error(`\nDynamoBEEmailService readFile ERROR (0), Couldn't load email template; ${templateName} from ${templatePath}\nerror:\n`, err, '\n');
-            reject(err);
-            return;
-          } else {
-            this.templates[templateName] = template;
-            this.templatePropertyKeys[templateName] = this.getTemplatePropertyKeys(template);
+      if (!this.componentsByName[componentName]) {
+        throw new Dynamo_Error({
+          ...this._getDefaultErrorSettings(
+            'setupComponent',
+            new Error(`No email component found with this name! (${componentName})`),
+            issuer
+          ),
+
+          errorCode: 'NTS-ES0-SC1',
+          additionalContent: {
+            availableComponenets: Object.keys(this.componentsByName),
+          },
+        });
+      }
+
+      const component: DynamoNTS_EmailTemplateComponent = this.componentsByName[componentName];
+      let template: string = this.compileHTMLMainFrame(component);
+
+      template = template.replace('<nts-content>', '');
+      template = this.compileComponentProperties<T>(
+        component, 
+        componentProperties, 
+        template, 
+        issuer
+      );
+
+      component.subComponentSelectors.forEach((subComponentSelector: string): void => {
+        while (template.includes(`<nts-${subComponentSelector}`)) {
+          template = this.compileSubComponent<T>(
+            subComponentSelector, componentProperties, template, issuer
+          );
+        }
+      });
+
+      template = this.templateTrim(template);
+      
+      return template;
+    } catch (error) {
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings('setupComponent', error, issuer),
+
+        errorCode: 'NTS-ES0-SC0',
+        message: `setupComponent failed! (${componentName})`,
+      });
+    }
+  }
+
+  private compileHTMLMainFrame(component: DynamoNTS_EmailTemplateComponent): string {
+    const allLinks: string[] = [];
+    const allStyles: string[] = [];
+
+    if (component.headerLinks) {
+      allLinks.push(component.headerLinks);
+    }
+
+    if (component.styles) {
+      allStyles.push(component.styles);
+    }
+
+    component.subComponentSelectors.forEach((subComponentSelector: string): void => {
+      const subComponent: DynamoNTS_EmailTemplateComponent = 
+        this.componentsBySelector[subComponentSelector];
+
+      if (subComponent.headerLinks) {
+        allLinks.push(subComponent.headerLinks.trim());
+      }
+
+      if (subComponent.styles) {
+        allStyles.push(subComponent.styles.trim());
+      }
+    });
+
+    const styles = this.styleTrim(allStyles.join(''));
+    const styleSize = this.getStringKBSize(styles);
+
+    if (this.styleLimitWarning < styleSize) {
+      Dynamo_Log.warn(
+        `\nDynamoNTS EmailService WARNING (${this.serviceName}), ` +
+        `\nEmail template styles are too big! (${styleSize}KB)` + 
+        `\ncomponent: ${component.name} (${component.selector})` +
+        `\nSome email clients may not support this!` +
+        `\nThe limit is ${this.styleLimitWarning}KB!`
+      );
+    }
+
+    return  `\n<!DOCTYPE html>` +
+            `\n<html>` +
+            `\n  <head>` +
+            `\n    ${allLinks.join('')}` +
+            `\n` +
+            `\n    <style>` +
+            `\n      ${styles}` +
+            `\n    </style>` +
+            `\n  </head>` +
+            `\n  <body>` +
+            `\n    ${component.template}` +
+            `\n  </body>` +
+            `\n</html> `;
+  }
+
+  /** trims all rows and remove everything between /*...*\/  */
+  private styleTrim(style: string): string {
+    let result: string = style.split('\n').map((row: string): string => row.trim()).join('');
+
+    while (result.includes('/*')) {
+      const start = result.indexOf('/*');
+      const end = result.indexOf('*/', start) + 2;
+
+      result = result.substring(0, start) + result.substring(end);
+    }
+
+    return result;
+  }
+
+  /** removes HTML comments */
+  private templateTrim(template: string): string {
+    let result: string = template;
+
+    while (result.includes('<!--')) {
+      const start = result.indexOf('<!--');
+      const end = result.indexOf('-->', start) + 3;
+
+      result = result.substring(0, start) + result.substring(end);
+    }
+
+    return result;
+  }
+
+
+  private getStringKBSize(str: string): number {
+    const b: number = str.length * 2;
+
+    return b / 1024;
+  }
+
+  private compileComponentProperties<T>(
+    component: DynamoNTS_EmailTemplateComponent, 
+    componentProperties: T, 
+    template: string, 
+    issuer: string
+  ): string {
+    component.properties.forEach((propertyKey: string): void => {
+      if (!componentProperties[propertyKey]) {
+        throw new Dynamo_Error({
+          ...this._getDefaultErrorSettings(
+            'setupComponent',
+            new Error(
+              `ComponentProperty missing from input! ${propertyKey} for ${component.name}`
+            ),
+            issuer
+          ),
+
+          errorCode: 'NTS-ES0-SC4',
+          additionalContent: {
+            componentProperties: Object.keys(componentProperties),
+          },
+        });
+      }
+
+      const propReg = new RegExp(`{{${propertyKey}}}`, 'g');
+
+      template = template.replace(propReg, componentProperties[propertyKey]);
+    });
+
+    return template;
+  }
+
+  private compileSubComponent<T>(
+    subComponentSelector: string, 
+    componentProperties: T,
+    template: string,
+    issuer: string
+  ): string {
+    const subComponent: DynamoNTS_EmailTemplateComponent = 
+      this.componentsBySelector[subComponentSelector];
+
+    if (!subComponent) {
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings(
+          'setupComponent',
+          new Error(`SubComponent missing from components! (${subComponentSelector})`),
+          issuer
+        ),
+
+        errorCode: 'NTS-ES0-SC2',
+        additionalContent: this.componentsBySelector,
+      });
+    }
+
+    let subComponentTemplate: string = subComponent.template;
+    const startTag = `<nts-${subComponent.selector}`;
+    const endTag = `</nts-${subComponent.selector}>`;
+    const tagHTMLProperties: string = 
+      template.split(startTag)[1].split('>')[0];
+    let componentContent: string;
+
+    if (!tagHTMLProperties) {
+      componentContent = template.split(`${startTag}>`)[1].split(endTag)[0];
+    } else {
+      componentContent = template.split(startTag)[1].split('>')[1].split(endTag)[0];
+    }
+
+    const contentReg = new RegExp(`<nts-content>`, 'g');
+
+    subComponentTemplate = subComponentTemplate.replace(contentReg, componentContent);
+    subComponentTemplate = this.compileComponentProperties<T>(
+      subComponent, 
+      componentProperties, 
+      subComponentTemplate, 
+      issuer
+    );
+
+    const startTagReg = new RegExp(startTag, 'g');
+    const endTagReg = new RegExp(endTag, 'g');
+
+    template = template.replace(startTagReg, '<div');
+    template = template.replace(componentContent, subComponentTemplate);
+    template = template.replace(endTagReg, '</div>');
+
+    /* while (template.includes(`<nts-${subComponent.selector}`)) {
+      const replaceStartIndex = template.indexOf(`<nts-${subComponent.selector}`);
+      const replaceEndIndex = template.indexOf(endTag, replaceStartIndex) + endTag.length;
+
+      template =
+        template.substring(0, replaceStartIndex) +
+        subComponentCompiled +
+        template.substring(replaceEndIndex);
+    } */
+
+    return template;
+  }
+
+  private async loadComponent(component: DynamoNTS_EmailTemplateComponent): Promise<void> {
+    try {
+      if (this.componentsBySelector[component.selector]) {
+        throw new Dynamo_Error({
+          ...this._getDefaultErrorSettings('loadComponent', new Error(), 'SYSTEM'),
 
-            this.templateLoadingInProgressCounter--;
-            if (this.templateLoadingInProgressCounter == 0) {
-              this.constructionFinished();
+          errorCode: 'NTS-ES0-LC1',
+          message: `Template already loaded! (${component.name})`,
+        });
+      }
+
+      if (!component.templatePath && !component.template) {
+        throw new Dynamo_Error({
+          ...this._getDefaultErrorSettings('loadComponent', new Error(), 'SYSTEM'),
+
+          errorCode: 'NTS-ES0-LC2',
+          message: `Component missing template and templatePath! (${component.name})`,
+        });
+      }
+
+      if (!component.template) {
+        await new Promise<void>((resolve, reject): void => {
+          FileSystem.readFile(component.templatePath, 'utf8' , (err, template): void => {
+            if (err || !template) {
+              if (!err) {
+                err = new Error(
+                  `Couldn't load email component's template; ${component.name} ` + 
+                  `from ${component.templatePath}`
+                );
+              }
+
+              reject(
+                new Dynamo_Error({
+                  ...this._getDefaultErrorSettings('loadTemplate', err, 'SYSTEM'),
+
+                  errorCode: 'NTS-ES0-LC3',
+                })
+              );
+
+              return;
             }
+
+            component.template = template;
+            
             resolve();
-          }
+          });
+        });
+      }
+
+      if (component.stylePath) {
+        await new Promise<void>((resolve, reject): void => {
+          FileSystem.readFile(component.stylePath, 'utf8' , (err, styles): void => {
+            if (err || !styles) {
+              if (!err) {
+                err = new Error(
+                  `Couldn't load email component's styles; ${component.name} ` + 
+                  `from ${component.stylePath}`
+                );
+              }
+
+              reject(
+                new Dynamo_Error({
+                  ...this._getDefaultErrorSettings('loadTemplate', err, 'SYSTEM'),
+
+                  errorCode: 'NTS-ES0-LC4',
+                })
+              );
+
+              return;
+            }
+
+            component.styles = styles;
+            
+            resolve();
+          });
         });
+      }
+
+      component.properties = this.getTemplatePropertyKeys(component.template);
+      this.componentsBySelector[component.selector] = component;
+      this.componentsByName[component.name] = component;
+
+      component.properties.forEach((propertyKey: string): void => {
+        if (!component.template.includes(`{{${propertyKey}}}`)) {
+          throw new Dynamo_Error({
+            ...this._getDefaultErrorSettings(
+              'loadComponent',
+              new Error(
+                `TemplateProperty missing from template! (${propertyKey} for ${component.name})`
+              ),
+              'SYSTEM'
+            ),
+    
+            errorCode: 'NTS-ES0-LC5',
+            additionalContent: component.template,
+          });
+        }
       });
     } catch (error) {
-      Dynamo_Log.error(`\nDynamoBEEmailService ERROR (1), Couldn't load email template; ${templateName} from ${templatePath}`, new Error());
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings('loadComponent', error, 'SYSTEM'),
+
+        errorCode: 'NTS-ES0-LC0',
+        message: `loadComponent failed! (${component.name})`,
+      });
+    }
+  }
+
+  private connectComponents(): void {
+    try {
+      for (const componentSelector in this.componentsBySelector) {
+        this.componentsBySelector[componentSelector].subComponentSelectors = [];
+
+        const innerTags: string[] = 
+          this.componentsBySelector[componentSelector].template.split('<nts-');
+
+        innerTags.shift();
+        innerTags.forEach(
+          (subComponents: string): void => {
+            const subComponentSelector = subComponents.split('>')[0].split(' ')[0];
+
+            if (subComponentSelector !== 'content') {
+              const fullSelector = 'nts-' + subComponentSelector;
+  
+              if (fullSelector) {
+                if (!this.componentsBySelector[subComponentSelector]) {
+                  throw new Dynamo_Error({
+                    ...this._getDefaultErrorSettings(
+                      'connectComponents',
+                      new Error(`SubComponent missing from components! (${fullSelector})`),
+                      'SYSTEM'
+                    ),
+
+                    errorCode: 'NTS-ES0-CC1',
+                    additionalContent: {
+                      availableComponenets: Object.keys(this.componentsBySelector),
+                    },
+                  });
+                }
+  
+                this.componentsBySelector[componentSelector].subComponentSelectors.push(
+                  subComponentSelector
+                );
+              }
+            }
+          }
+        );
+      }
+    } catch (error) {
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings('connectComponents', error, 'SYSTEM'),
+
+        errorCode: 'NTS-ES0-CC0',
+        message: `connectComponents failed!`,
+      });
     }
   }
 
@@ -233,31 +621,51 @@ export class DynamoNTS_EmailService {
 
       while (propertyOpenTagIndex >= 0) {
         if (propertyCloseTagIndex === -1) {
-          Dynamo_Log.error(`\nDynamoBEEmailService ERROR, missing closing tag from email template! (${propertyOpenTagIndex} -)`, propertyKeys);
+          Dynamo_Log.error(
+            `\nDynamoBEEmailService ERROR, missing closing tag from email template! ` +
+            `(${propertyOpenTagIndex} -)`, 
+            propertyKeys
+          );
+
           throw new Dynamo_Error({ 
-            errorCode: 'NTS-ES4-200',
+            errorCode: 'NTS-ES0-200',
             addECToUserMsg: true,
             message: `ERROR, missing closing tag from email template! (${propertyOpenTagIndex} -)`,
-            userMessage: this.defaultErrorUserMsg
+            userMessage: this.defaultErrorUserMsg,
           });
         }
 
         const newKey: string = template.substring(propertyOpenTagIndex + 2, propertyCloseTagIndex);
+
         if (!propertyKeys.includes(newKey)) {
           propertyKeys.push(newKey);
         }
 
+        // KELLEZIDE?
         propertyOpenTagIndex = template.indexOf('{{', propertyOpenTagIndex + 2);
         propertyCloseTagIndex = template.indexOf('}}', propertyOpenTagIndex + 2);
       }
       // console.log('\n\n\nTEST propertyKeys: ', propertyKeys);
+
       return propertyKeys;
     } catch (error) {
-      Dynamo_Log.error(`\nDynamoBEEmailService ERROR, getTemplatePropertyKeys ERROR`, new Error(), '\ntemplate:\n', template);
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings('getTemplatePropertyKeys', error, 'SYSTEM'),
+
+        errorCode: 'NTS-ES0-GTPK0',
+        message: `getTemplatePropertyKeys failed!`,
+        additionalContent: template,
+      });
     }
   }
   
-  private _getDefaultErrorSettings(fnName: string, error: Error | Dynamo_Error, issuer: string) {
+  
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  private _getDefaultErrorSettings(
+    fnName: string, 
+    error: Error | Dynamo_Error, 
+    issuer: string
+  )/* : Dynamo_ErrorSettings */ {
     return {
       status: (error as Dynamo_Error)?.___status ?? 500,
       message: (error as Error)?.message ?? `${fnName} was UNSUCCESFUL (NTS; ${this.serviceName})`,
@@ -266,6 +674,6 @@ export class DynamoNTS_EmailService {
       issuer: issuer,
       issuerService: this.serviceName,
       error: error,
-    }
+    };
   }
 }