@futdevpro/nts-dynamo 1.2.90

package/src/_services/dynamobe-email.service.ts

@@ -0,0 +1,169 @@
+
+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 { DynamoBEError } from '../_models/fullstack-models/control-models/dynamobe-error';
+import { DBE_Shared } from './dynamobe-shared.service';
+
+export class DynamoBEEmailService {
+  private nmTransporter: NodeMailer.Transporter;
+  private senderName: string;
+  private senderNEmail: string;
+  private templates: {
+    [templateName: string]: string
+  } = {};
+  private templatePropertyKeys: {
+    [templateName: string]: string[]
+  } = {};
+  private templateLoadingInProgressCounter = 0;
+  
+  constructor (
+    set: {
+      host: string,
+      port: number,
+      email: string,
+      pass: string,
+      senderName: string,
+      /* constructionFinishedCallback: () => void, */
+      templatePaths: {
+        [templateName: string]: string
+      },
+    }
+  ) {
+    try {
+      // 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
+        }
+      });
+      /* this.constructionFinishedCallback = set.constructionFinishedCallback; */
+      if (set.templatePaths) {
+        for(let key in set.templatePaths) {
+          this.loadTemplate(key, set.templatePaths[key]);
+        }
+      } else {
+        this.constructionFinished();
+      }
+    } catch (error) {
+      console.log(`\nDynamoBEEmailService ERROR, The emailService construction failed for ${set.email}.`, new Error());
+    }
+  }
+
+  private constructionFinished(): void { 
+    DBE_Shared.logSuccess(`\n${this.senderName} EmailService construction finished\n`) 
+  }
+
+  public async sendEmail(set: {
+    to: string,
+    subject: string,
+    content?: string,
+    useTemplate?: string,
+    templateProperties?: {
+      [propertyKey: string]: string
+    },
+    attachments?: Attachment[]
+  }): Promise<void> {
+    try {
+      let content: string;
+
+      if (set.content) {
+        content = set.content
+      } else if (set.useTemplate) {
+        if (!this.templates[set.useTemplate]) {
+          throw new DynamoBEError({ message: `no template found with this parameter! (${set.useTemplate})` });
+        }
+        content = this.templates[set.useTemplate];
+
+        if (this.templatePropertyKeys[set.useTemplate].length > 0) {
+          if (!set.templateProperties) {
+            throw new DynamoBEError({ message: `templateProperties missing!` });
+          }
+          this.templatePropertyKeys[set.useTemplate].forEach((propertyKey: string) => {
+            if (!set.templateProperties[propertyKey]) {
+              console.log(`templateProperty missing! (${propertyKey})`);
+            }
+            const reg = new RegExp(`{{${propertyKey}}}`, 'g')
+            content = content.replace(reg, set.templateProperties[propertyKey]);
+          })
+        }
+      } else {
+        throw new DynamoBEError({ message: 'no content setting passsed to emailSending!' });
+      }
+
+      let mailOptions: MailOptions = {
+        from: this.senderNEmail,
+        to: set.to,
+        subject: set.subject,
+        html: content,
+        attachments: set.attachments,
+        
+      };
+
+      await this.nmTransporter.sendMail(mailOptions, (error, info) => { 
+        if (error) {
+          throw error;
+        }
+      });
+    } catch (error) {
+      console.log('\nDynamoBEEmailService ERROR, email sending error', error);
+    }
+  }
+
+  private async loadTemplate(templateName: string, templatePath: string): Promise<void> {
+    try {
+      this.templateLoadingInProgressCounter++;
+      return new Promise<void>((resolve, reject) => {
+        templatePath = Path.join(__dirname, templatePath);
+        FileSystem.readFile(templatePath, 'utf8' , (err, template) => {
+          if (err) {
+            console.log(`\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);
+
+            this.templateLoadingInProgressCounter--;
+            if (this.templateLoadingInProgressCounter == 0) {
+              this.constructionFinished();
+            }
+            resolve();
+          }
+        });
+      });
+    } catch (error) {
+      console.log(`\nDynamoBEEmailService ERROR (1), Couldn't load email template; ${templateName} from ${templatePath}`, new Error());
+    }
+  }
+
+  private getTemplatePropertyKeys(template: string): string[] {
+    try {
+      const propertyKeys: string[] = [];
+      let propertyOpenTagIndex = template.indexOf('{{');
+      let propertyCloseTagIndex = template.indexOf('}}', propertyOpenTagIndex + 2);
+      while (propertyOpenTagIndex >= 0) {
+        if (propertyCloseTagIndex === -1) {
+          console.log(`\nDynamoBEEmailService ERROR, missing closing tag from email template! (${propertyOpenTagIndex} -)`, propertyKeys);
+          throw new DynamoBEError({ message: `ERROR, missing closing tag from email template! (${propertyOpenTagIndex} -)` });
+        }
+        const newKey: string = template.substring(propertyOpenTagIndex + 2, propertyCloseTagIndex);
+        if (!propertyKeys.includes(newKey)) {
+          propertyKeys.push(newKey);
+        }
+        propertyOpenTagIndex = template.indexOf('{{', propertyOpenTagIndex + 2);
+        propertyCloseTagIndex = template.indexOf('}}', propertyOpenTagIndex + 2);
+      }
+      // console.log('\n\n\nTEST propertyKeys: ', propertyKeys);
+      return propertyKeys;
+    } catch (error) {
+      console.log(`\nDynamoBEEmailService ERROR, getTemplatePropertyKeys ERROR`, new Error(), '\ntemplate:\n', template);
+    }
+  }
+}

package/src/_services/dynamobe-global.service.ts

@@ -0,0 +1,99 @@
+
+
+import { DynamoBERouteSecurity } from '../_enum/dynamobe-route-security.enum';
+import { DynamoBEGlobalSettings } from '../_models/dynamobe-global-settings';
+import { DynamoBEAuthService } from './dynamobe-auth.service';
+import { DynamoBEDBServiceCollection } from './dynamobe-db-service-collection.service';
+import { DynamoBEEmailServiceCollection } from './dynamobe-email-service-collection.service';
+import { DynamoBESingletonService } from './dynamobe-singleton.service';
+
+export class DBE_Global_S extends DynamoBESingletonService {
+
+  static getInstance(): DBE_Global_S {
+    return DBE_Global_S.getSingletonInstance();
+  }
+  
+  globalSettings: DynamoBEGlobalSettings = {
+    defaultRouteSecurity: DynamoBERouteSecurity.open,
+    logSetup: false,
+    logRequests: true,
+    logRequestsContent: true,
+    logResponseContent: false,
+  };
+
+  authService: DynamoBEAuthService;
+  dbServiceCollection: DynamoBEDBServiceCollection;
+  emailServiceCollection: DynamoBEEmailServiceCollection;
+  
+  static setServices(
+    set: {
+      authService: DynamoBEAuthService,
+      dbServiceCollection: DynamoBEDBServiceCollection,
+      emailServiceCollection: DynamoBEEmailServiceCollection,
+    }
+  ): void {
+    this.getInstance();
+    this.instance.authService = set.authService;
+    this.instance.dbServiceCollection = set.dbServiceCollection;
+    this.instance.emailServiceCollection = set.emailServiceCollection;
+  }
+
+  static getGlobalSettings(): DynamoBEGlobalSettings {
+    if (!this.instance) {
+      throw new Error(`DynamoBE Global Service missing!` + 
+        `\nPlease setup DynamoBE Global Service by calling "DBE_Global_SC.setServices(...)"` +
+        `before calling getGlobalSettings"`);
+    }
+    return this.instance.globalSettings;
+  }
+
+  static setGlobalSettings(set: DynamoBEGlobalSettings): void {
+    if (!this.instance) {
+      throw new Error(`DynamoBE Global Service missing!` + 
+        `\nPlease setup DynamoBE Global Service by calling "DBE_Global_SC.setServices(...)"` +
+        `before calling setGlobalSettings"`);
+    }
+    if (set.defaultRouteSecurity) {
+      this.instance.globalSettings.defaultRouteSecurity = set.defaultRouteSecurity;
+    }
+    if (set.logSetup !== undefined) {
+      this.instance.globalSettings.logSetup = set.logSetup;
+    }
+    if (set.logRequests !== undefined) {
+      this.instance.globalSettings.logRequests = set.logRequests;
+    }
+    if (set.logRequestsContent !== undefined) {
+      this.instance.globalSettings.logRequestsContent = set.logRequestsContent;
+    }
+    if (set.logResponseContent !== undefined) {
+      this.instance.globalSettings.logResponseContent = set.logResponseContent;
+    }
+  }
+
+  static getAuthService(): DynamoBEAuthService {
+    if (!this.instance?.authService?.authenticateToken) {
+      throw new Error(`Unique Authentication Service missing!` + 
+        `\nPlease create a Unique Authentication Service extending DynamoBEAuthService, ` + 
+        `and Setup with "DBE_Global_SC.setServices(...)"`);
+    }
+    return this.instance.authService;
+  }
+
+  static getDBServiceCollection(): DynamoBEDBServiceCollection {
+    if (!this.instance?.dbServiceCollection) {
+      throw new Error(`Unique DataBase Service Collection missing!` + 
+        `\nPlease create a Unique DataBase Service Collectio extending DynamoBEDBServiceCollection, ` + 
+        `and Setup with "DBE_Global_SC.setServices(...)"`);
+    }
+    return this.instance.authService;
+  }
+
+  static getEmailServiceCollection(): DynamoBEEmailServiceCollection {
+    if (!this.instance?.emailServiceCollection) {
+      throw new Error(`Unique Email Service Collection missing!` + 
+        `\nPlease create a Unique Email Service Collection extending DynamoBEEmailServiceCollection, ` + 
+        `and Setup with "DBE_Global_SC.setServices(...)"`);
+    }
+    return this.instance.emailServiceCollection;
+  }
+}

package/src/_services/dynamobe-routing-module.service.ts

@@ -0,0 +1,141 @@
+
+import { Router } from 'express';
+import { DynamoBERouteSecurity } from '../_enum/dynamobe-route-security.enum';
+import { HttpCallType } from '../_enum/http/http-call-type.enum';
+import { DynamoBEEndpointParams } from '../_models/dynamobe-endpoint-control';
+import { DynamoBEError } from '../_models/fullstack-models/control-models/dynamobe-error';
+import { DynamoBEController } from './dynamobe-controller.service';
+import { DBE_Global_S } from './dynamobe-global.service';
+
+export class DynamoBERountingModule {
+  
+  security: DynamoBERouteSecurity;
+  route: string;
+
+  private controllers: DynamoBEController[];
+  endpoints: DynamoBEEndpointParams[] = [];
+
+  openRouter: Router = Router();
+  secureRouter: Router = Router();
+
+  protected log: boolean = DBE_Global_S.getGlobalSettings().logSetup;
+
+  constructor(
+    set: {
+      route: string,
+      controllers: DynamoBEController[],
+      securityOverride?: DynamoBERouteSecurity,
+    }
+  ){
+    
+    this.route = set.route;
+    this.controllers = set.controllers;
+    this.setupRoutes();
+    this.mountRoutes(set.securityOverride);
+
+    if (this.log) console.log(`routing module setup done: ${this.route} serurity: ${this.security}\n`);
+  }
+
+  /**
+   * You must setup endpoints and required services in this function
+   */
+  setupRoutes(): void {
+    this.controllers.forEach((controller: DynamoBEController) => {
+      this.endpoints.push(...controller.endpoints);
+    });
+  }
+
+  private mountRoutes(securityOverride?: DynamoBERouteSecurity): void {
+    if (securityOverride) {
+      this.security = securityOverride;
+    }
+    this.endpoints.forEach((endpoint: DynamoBEEndpointParams) => {
+      if (securityOverride) {
+        endpoint.security = securityOverride;
+      } else {
+        if (!this.security) {
+          this.security = endpoint.security;
+        } else if (this.security !== endpoint.security) {
+          this.security = DynamoBERouteSecurity.both;
+        }
+      }
+
+      if (this.log) console.log(`endpoint mount (${endpoint.security}): ${this.route}${endpoint.endpoint}`);
+      const existingEndPoints: DynamoBEEndpointParams[] = this.endpoints.filter(
+          (ep: DynamoBEEndpointParams) => ep.endpoint === endpoint.endpoint);
+      if (1 < existingEndPoints.length) {
+        let error = new Error(`ENDPOINT DUPLICATION: ${endpoint.endpoint}`);
+        let errorStack: string[] = error.stack.split('\n');
+        errorStack.splice(1, 4);
+        error.stack = errorStack.join('\n');
+
+        throw error;
+      }
+
+      try {
+        if (endpoint.security !== DynamoBERouteSecurity.secure) {
+          this.mountOpenRoute(endpoint);
+        }
+        if (endpoint.security !== DynamoBERouteSecurity.open) {
+          this.mountSecureRoute(endpoint);
+        }
+      } catch (error) {
+        throw new DynamoBEError({ message: `DYNAMOBEERROR: Failed to mount routes.`, error })
+      }
+    });
+  }
+
+  private mountOpenRoute(endpointParams: DynamoBEEndpointParams): void {
+    switch(endpointParams.type) {
+      case HttpCallType.get:
+        this.openRouter.get(endpointParams.endpoint, 
+          endpointParams.preProcessess, endpointParams.getTasksExecution());
+        break;
+      case HttpCallType.post:
+          this.openRouter.post(endpointParams.endpoint, 
+            endpointParams.preProcessess, endpointParams.getTasksExecution());
+        break;
+      case HttpCallType.put:
+        this.openRouter.put(endpointParams.endpoint, 
+          endpointParams.preProcessess, endpointParams.getTasksExecution());
+        break;
+      case HttpCallType.patch:
+        this.openRouter.patch(endpointParams.endpoint, 
+          endpointParams.preProcessess, endpointParams.getTasksExecution());
+        break;
+      case HttpCallType.delete:
+        this.openRouter.delete(endpointParams.endpoint, 
+          endpointParams.preProcessess, endpointParams.getTasksExecution());
+        break;
+      default:
+        throw new DynamoBEError({ message: `DYNAMOBEERROR: INVALID route type: ${endpointParams.type} - ${endpointParams.name}` })
+    }
+  }
+
+  private mountSecureRoute(endpointParams: DynamoBEEndpointParams): void {
+    switch(endpointParams.type) {
+      case HttpCallType.get:
+        this.secureRouter.get(endpointParams.endpoint, 
+          endpointParams.preProcessess, endpointParams.getTasksExecution());
+        break;
+      case HttpCallType.post:
+        this.secureRouter.post(endpointParams.endpoint, 
+          endpointParams.preProcessess, endpointParams.getTasksExecution());
+        break;
+      case HttpCallType.put:
+        this.secureRouter.put(endpointParams.endpoint, 
+          endpointParams.preProcessess, endpointParams.getTasksExecution());
+        break;
+      case HttpCallType.patch:
+        this.secureRouter.patch(endpointParams.endpoint, 
+          endpointParams.preProcessess, endpointParams.getTasksExecution());
+        break;
+      case HttpCallType.delete:
+        this.secureRouter.delete(endpointParams.endpoint, 
+          endpointParams.preProcessess, endpointParams.getTasksExecution());
+        break;
+      default:
+        throw new DynamoBEError({ message: `DYNAMOBEERROR: INVALID route type: ${endpointParams.type} - ${endpointParams.name}` })
+    }
+  }
+}

package/src/_services/dynamobe-server.ts

@@ -0,0 +1,225 @@
+
+
+/* import * as Express from 'express'; */
+/* import { e as Express } from 'express'; */
+import Express = require("express")
+
+/* import express from 'express'; */
+import * as Https from 'https';
+import * as FileSystem from 'fs';
+import * as BodyParser from 'body-parser';
+import { DynamoBERountingModule } from './dynamobe-routing-module.service';
+import { DynamoBESingletonService } from './dynamobe-singleton.service';
+import { DynamoBERouteSecurity } from '../_enum/dynamobe-route-security.enum';
+import { DBE_Shared } from './dynamobe-shared.service';
+import { DynamoBEEndpointParams } from '../_models/dynamobe-endpoint-control';
+import { DBE_Global_S } from './dynamobe-global.service';
+
+export abstract class DynamoBEServer extends DynamoBESingletonService {
+
+  protected security: DynamoBERouteSecurity;
+
+  protected httpPort?: number;
+  protected httpsPort?: number;
+
+  protected cert?: {
+    keyPath: FileSystem.PathLike,
+    certPath: FileSystem.PathLike,
+  };
+
+  private secureExpress: Express.Application;
+  private httpsServer: Https.Server;
+  private openExpress: Express.Application;
+
+  protected routingModules: DynamoBERountingModule[];
+
+  protected log: boolean = DBE_Global_S.getGlobalSettings().logSetup;
+
+  protected constructor(){
+    super();
+
+    this.setupRoutingModules();
+    this.setSecurity();
+        
+    this.initExpresses();
+    this.startExpresses();
+
+    if (this.security !== DynamoBERouteSecurity.secure) {
+      this.mountOpenRoutes();
+    }
+    if (this.security !== DynamoBERouteSecurity.open && this.cert) {
+      this.mountSecureRoutes();
+    }
+
+    if (this.log) console.log(`\nRoutes mounted.... server using security: ${this.security}`);
+  }
+
+  private initExpresses() {
+    if (this.security !== DynamoBERouteSecurity.secure) {
+      if (!this.httpPort) {
+        let errorMsg: string =
+          `You have open routes, but httpPort is not set!` +
+          `\nsecurity: ${this.security}` +
+          `\nset httpPort in DynamoBEServer - setupRoutingModules() to enable secure routes.`;
+        
+        errorMsg += '\n\nThe routes setted to use open server:';
+        this.routingModules.forEach((module: DynamoBERountingModule) => {
+          if (module.security != DynamoBERouteSecurity.secure) {
+            errorMsg += `\n  ${module.route} (security: ${module.security}) \n  subroutes using open sever:`;
+            module.endpoints.forEach((endpoint: DynamoBEEndpointParams) => {
+              if (endpoint.security != DynamoBERouteSecurity.secure) {
+                errorMsg += `\n    ${endpoint.endpoint} (security: ${endpoint.security})`;
+              }
+            });
+          }
+        });
+        DBE_Shared.logError(errorMsg);
+
+        let error = new Error('Open routes cannot be established!');
+        let errorStack: string[] = error.stack.split('\n');
+        errorStack.splice(1, 2);
+        error.stack = errorStack.join('\n');
+
+        throw error;
+      }
+
+      this.initOpenExpress();
+    }
+
+    if (this.security !== DynamoBERouteSecurity.open) {
+      if (!this.cert || !this.httpsPort) {
+        let errorMsg: string =
+          `You have secure routes, but the certification paths or httpsPort are not set!` +
+          `\nsecurity: ${this.security}` +
+          `\nset...` +
+          `\n  httpsPort and` +
+          `\n  cert: {` +
+          `\n    keyPath: FileSystem.PathLike,` +
+          `\n    certPath: FileSystem.PathLike,` +
+          `\n  }` +
+          `\nin DynamoBEServer - setupRoutingModules() to enable secure routes.`;
+        
+        errorMsg += '\n\nThe routes setted to use secure server:';
+        this.routingModules.forEach((module: DynamoBERountingModule) => {
+          if (module.security != DynamoBERouteSecurity.open) {
+            errorMsg += `\n  ${module.route} (security: ${module.security}) \n  subroutes using secure sever:`;
+            module.endpoints.forEach((endpoint: DynamoBEEndpointParams) => {
+              if (endpoint.security != DynamoBERouteSecurity.open) {
+                errorMsg += `\n    ${endpoint.endpoint} (security: ${endpoint.security})`;
+              }
+            });
+          }
+        });
+        DBE_Shared.logError(errorMsg);
+
+        let error = new Error('Secure routes cannot be established!');
+        let errorStack: string[] = error.stack.split('\n');
+        errorStack.splice(1, 2);
+        error.stack = errorStack.join('\n');
+
+        throw error;
+      }
+
+      this.initSecureExpress();
+    }
+  }
+
+  private initOpenExpress(): void {
+    this.openExpress = Express();    
+    this.openExpress.use(BodyParser.urlencoded({ limit: '50mb', extended: true }));
+    this.openExpress.use(BodyParser.json({ limit: '50mb' }));
+  }
+
+  private initSecureExpress(): void {
+    this.secureExpress = Express();    
+    this.secureExpress.use(BodyParser.urlencoded({ limit: '50mb', extended: true }));
+    this.secureExpress.use(BodyParser.json({ limit: '50mb' }));
+
+    const options = {
+      key: FileSystem.readFileSync(this.cert.keyPath),
+      cert: FileSystem.readFileSync(this.cert.certPath),
+    };
+    this.httpsServer = Https.createServer(options, this.secureExpress);
+  }
+
+  private async startExpresses(): Promise<void> {
+    if (this.security !== DynamoBERouteSecurity.open) {
+      this.httpsServer
+        .listen(this.httpsPort, 'localhost', 0, () => {
+          DBE_Shared.logSuccess(`\nHTTPS (secure) server is listening on port ${this.httpsPort}\n`);
+        })
+        .on('error', (error) => {
+          DBE_Shared.logError(`https (secure) server ERROR`, error);
+        })
+        .on('uncaughtException', (ex) => {
+          DBE_Shared.logWarning(`https (secure) server uncaughtException`, ex);
+        });
+    }
+
+    if (this.security !== DynamoBERouteSecurity.secure) {
+      this.openExpress
+        .listen(this.httpPort, () => {
+          DBE_Shared.logSuccess(`\nHTTP  (-open-) server is listening on port ${this.httpPort}\n`);
+        })
+        .on('error', (error) => {
+          DBE_Shared.logError(`http  (-open-) server ERROR`, error);
+        })
+        .on('uncaughtException', (ex) => {
+          DBE_Shared.logWarning(`http  (-open-) server uncaughtException`, ex);
+        });
+    }
+  }
+
+  private mountSecureRoutes (): void {
+    this.routingModules.forEach((module: DynamoBERountingModule) => {
+      if (module.security !== DynamoBERouteSecurity.open) {
+        if (this.log) console.log(`route mount (secure): ${module.route}`);
+        const existingRoutes: DynamoBERountingModule[] = this.routingModules.filter(
+            (mod: DynamoBERountingModule) => mod.route === module.route);
+        if (1 < existingRoutes.length) {
+          let error = new Error(`ROUTE DUPLICATION: ${module.route}`);
+          let errorStack: string[] = error.stack.split('\n');
+          errorStack.splice(1, 4);
+          error.stack = errorStack.join('\n');
+  
+          throw error;
+        }
+        this.secureExpress.use(module.route, module.secureRouter);
+      }
+    });
+  }
+
+  private mountOpenRoutes (): void {
+    this.routingModules.forEach((module: DynamoBERountingModule) => {
+      if (module.security !== DynamoBERouteSecurity.secure) {
+        if (this.log) console.log(`route mount (open): ${module.route}`);
+        const existingRoutes: DynamoBERountingModule[] = this.routingModules.filter(
+            (mod: DynamoBERountingModule) => mod.route === module.route);
+        if (1 < existingRoutes.length) {
+          let error = new Error(`ROUTE DUPLICATION: ${module.route}`);
+          let errorStack: string[] = error.stack.split('\n');
+          errorStack.splice(1, 4);
+          error.stack = errorStack.join('\n');
+  
+          throw error;
+        }
+        this.openExpress.use(module.route, module.openRouter);
+      }
+    });
+  }
+
+  private setSecurity(): void {
+    this.routingModules.forEach((module: DynamoBERountingModule) => {
+      if (!this.security) {
+        this.security = module.security;
+      } else if (this.security !== module.security) {
+        this.security = DynamoBERouteSecurity.both;
+      }
+    });
+  }
+
+  /**
+   * You must setup endpoints and required services in this function
+   */
+  abstract setupRoutingModules(): void;
+}