@futdevpro/nts-dynamo 1.2.90

package/nodemon.json

@@ -0,0 +1,6 @@
+{
+  "watch": ["src"],
+  "ext": ".ts,.js",
+  "ignore": [],
+  "exec": "ts-node ./src/index.ts"
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@futdevpro/nts-dynamo",
+  "version": "01.02.90",
+  "description": "Dynamic NodeTS (NodeJS-Typescript), MongoDB Backend System Framework by Future Development Ltd.",
+  "main": "./lib/index.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/futdevpro/dynamo-be.git"
+  },
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "npx tsc",
+    "build2": "rimraf ./build && tsc"
+  },
+  "keywords": [
+    "nodejs",
+    "typescript",
+    "mongodb"
+  ],
+  "author": "Future Development Program Ltd.",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://gitlab.com/futdevpro/dynamo-be/issues"
+  },
+  "homepage": "https:/futdevpro.hu/projects/dynamo",
+  "dependencies": {
+    "@types/express": "^4.17.7",
+    "@types/mongoose": "^5.7.34",
+    "@types/node": "^14.0.27",
+    "@types/oauth2orize": "^1.8.8",
+    "@types/passport": "^1.0.4",
+    "@types/axios": "^0.14.0",
+    "@types/geoip-lite": "^1.4.1",
+    "@types/jsonwebtoken": "^8.5.0",
+    "@types/nodemailer": "^6.4.4",
+    "axios": "^0.21.4",
+    "crypto-js": "^4.1.1",
+    "geoip-lite": "^1.4.5",
+    "express": "^4.17.1",
+    "mongoose": "^5.9.27",
+    "nodemon": "^2.0.4",
+    "passport": "^0.4.1",
+    "nodemailer": "^6.4.11",
+    "rimraf": "^3.0.2",
+    "ts-node": "^8.10.2",
+    "typescript": "^3.9.7",
+    "rxjs": "^7.4.0",
+    "jsonwebtoken": "^8.5.1",
+    "tslib": "^2.0.1"
+  }
+}

package/src/_constants/dynamobe-global.settings.ts

@@ -0,0 +1,11 @@
+
+import { DynamoBERouteSecurity } from '../_enum/dynamobe-route-security.enum';
+import { DynamoBEGlobalSettings } from '../_models/dynamobe-global-settings';
+
+export const dynamoBEDefaultGlobalSettings: DynamoBEGlobalSettings = {
+  defaultRouteSecurity: DynamoBERouteSecurity.open,
+  logSetup: false,
+  logRequests: true,
+  logRequestsContent: true,
+  logResponseContent: false,
+};

package/src/_enum/data-model-types.enum.ts

@@ -0,0 +1,6 @@
+
+export enum DataModelType {
+  dataModel = 'data-model',
+  controlModel = 'control-model',
+  interfaceModel = 'interface-model',
+}

package/src/_enum/dynamobe-data-service-function.enum.ts

@@ -0,0 +1,11 @@
+
+/* DataServiceFunction */
+export enum DynamoBEDSF {
+  getAll = 'getAll',
+  getDataById = 'getDataById',
+  /* checkIfDataExists = 'checkIfDataExists',
+  createData = 'createNewData', */
+  modifyData = 'modifyData',
+  deleteData = 'deleteData',
+  getProvidedData = 'getProvidedData',
+}

package/src/_enum/dynamobe-route-security.enum.ts

@@ -0,0 +1,6 @@
+
+export enum DynamoBERouteSecurity {
+  open = 'open',
+  secure = 'secure',
+  both = 'both',
+}

package/src/_enum/http/http-call-type.enum.ts

@@ -0,0 +1,8 @@
+
+export enum HttpCallType {
+  get = 'get',
+  post = 'post',
+  put = 'put',
+  patch = 'patch',
+  delete = 'delete'
+}

package/src/_enum/http/http-response-type.enum.ts

@@ -0,0 +1,7 @@
+
+export enum HttpResponseType {
+  arraybuffer = 'arraybuffer',
+  blob = 'blob',
+  json = 'json',
+  text = 'text'
+}

package/src/_enum/log-style.enum.ts

@@ -0,0 +1,30 @@
+
+
+export enum LogStyle {
+  reset = '\x1b[0m',
+
+  bright = '\x1b[1m',
+  dim = '\x1b[2m',
+  underline = '\x1b[4m',
+  blink = '\x1b[5m',
+  reverse = '\x1b[7m',
+  hidden = '\x1b[8m',
+
+  black = '\x1b[30m',
+  red = '\x1b[31m',
+  green = '\x1b[32m',
+  yellow = '\x1b[33m',
+  blue = '\x1b[34m',
+  magenta = '\x1b[35m',
+  cyan = '\x1b[36m',
+  white = '\x1b[37m',
+
+  BgBlack = '\x1b[40m',
+  BgRed = '\x1b[41m',
+  BgGreen = '\x1b[42m',
+  BgYellow = '\x1b[43m',
+  BgBlue = '\x1b[44m',
+  BgMagenta = '\x1b[45m',
+  BgCyan = '\x1b[46m',
+  BgWhite = '\x1b[47m',
+}

package/src/_enum/predefined-data-types.enum.ts

@@ -0,0 +1,8 @@
+
+export enum PredefinedDataTypes {
+  'string', 
+  'number',
+  'boolean',
+  'Date',
+  'object',
+}

package/src/_models/dynamobe-api-call-params.ts

@@ -0,0 +1,62 @@
+
+/* import { HttpHeaders, HttpParams } from '@angular/common/http'; */
+import { HttpCallType } from "../_enum/http/http-call-type.enum";
+import { HttpResponseType } from "../_enum/http/http-response-type.enum";
+
+export class DynamoBEApiCallParams {
+  name: string;
+  type: HttpCallType;
+  baseUrl: string;
+  endPoint: string;
+
+  httpOptions: any;
+
+  constructor(
+    settings: {
+      name: string,
+      type: HttpCallType,
+      endPoint: string,
+      baseUrl: string,
+      httpOptions?: HttpOptions,
+    }
+  ) {
+    this.name = settings.name;
+    this.type = settings.type;
+    this.endPoint = settings.endPoint;
+    this.baseUrl = settings.baseUrl;
+    this.httpOptions = settings.httpOptions ? settings.httpOptions : {};
+  }
+}
+
+export class HttpOptions {
+  responseType?: HttpResponseType;
+  /* params?: HttpParams | {
+    [param: string]: string | string[];
+  }; */
+  headers?: {
+    [header: string]: string | string[];
+  };
+  observe?: 'body';
+  reportProgress?: boolean;
+  withCredentials?: boolean;
+
+  constructor(options: {
+    responseType?: HttpResponseType,
+    /* params?: HttpParams | {
+      [param: string]: string | string[];
+    }, */
+    headers?: {
+      [header: string]: string | string[];
+    },
+    observe?: 'body',
+    reportProgress?: boolean,
+    withCredentials?: boolean
+  }) {
+    this.responseType = options.responseType;
+    /* this.params = options.params; */
+    this.headers = options.headers;
+    this.observe = options.observe;
+    this.reportProgress = options.reportProgress;
+    this.withCredentials = options.withCredentials;
+  }
+}

package/src/_models/dynamobe-app-params.ts

@@ -0,0 +1,24 @@
+
+export class DynamoBEAppParams {
+  name: string;
+  title: string;
+  version: string;
+  dbUri: string;
+  dbName: string;
+
+  constructor(
+    set: {
+      name: string,
+      title?: string,
+      version: string,
+      dbName: string,
+      dbUri?: string,
+    }
+  ) {
+    this.name = set.name;
+    this.title = set.title ? set.title : '';
+    this.version = set.version;
+    this.dbName = set.dbName;
+    this.dbUri = set.dbUri ? set.dbUri : `mongodb://localhost:27017/${this.dbName}`;
+  }
+}

package/src/_models/dynamobe-data-model-params.ts

@@ -0,0 +1,23 @@
+
+import { DataModelType } from '../_enum/data-model-types.enum';
+import { DynamoBEDataPropertyParams } from './fullstack-models/control-models/dynamobe-data-property-params';
+
+export class DynamoBEDataModelParams {
+  dataName: string;
+  type: DataModelType;
+  properties: DynamoBEDataPropertyParams[] = [];
+
+  constructor(
+    set?: {
+      dataName: string,
+      type: DataModelType,
+      properties: DynamoBEDataPropertyParams[],
+    }
+  ) {
+    if (set) {
+      this.dataName = set.dataName;
+      this.type = set.type;
+      this.properties = set.properties ? set.properties : [];
+    }
+  }
+}

package/src/_models/dynamobe-endpoint-control.ts

@@ -0,0 +1,127 @@
+
+
+import { NextFunction, Request, Response } from 'express';
+import { HttpCallType } from '../_enum/http/http-call-type.enum';
+import { DynamoBERouteSecurity as DynamoBERouteSecurity } from '../_enum/dynamobe-route-security.enum';
+import { DBE_Shared } from '../_services/dynamobe-shared.service';
+import { DBE_Global_S } from '../_services/dynamobe-global.service';
+
+export class DynamoBEEndpointParams{
+  name: string;
+  security: DynamoBERouteSecurity;
+
+  type: HttpCallType;
+  endpoint: string;
+
+  pathParams: string[];
+
+  preProcessess: ((req: Request, res: Response, next: NextFunction) => Promise<void>)[]
+  tasks: ((req: Request, res: Response, issuer?: string) => Promise<void>)[];
+
+  logRequest: boolean;
+  logRequestsContent: boolean;
+  logResponseContent: boolean;
+
+  constructor(
+    set: {
+      name: string,
+      security?: DynamoBERouteSecurity,
+
+      type: HttpCallType,
+      endpoint: string,
+      
+      preProcessess?: ((req: Request, res: Response, next: NextFunction) => Promise<void>)[],
+      tasks: ((req: Request, res: Response, issuer?: string) => Promise<void>)[],
+
+      logRequest?: boolean,
+      logRequestsContent?: boolean,
+      logResponseContent?: boolean,
+    }
+  ) {
+    this.name = set.name ? set.name : set.endpoint;
+    this.security = set.security ? set.security : DBE_Global_S.getGlobalSettings().defaultRouteSecurity;
+
+    this.type = set.type;
+    this.endpoint = set.endpoint;
+
+    let pathParts: string[] = this.endpoint.split('/');
+    pathParts = pathParts.filter((part: string) => part[0] === ':');
+    pathParts = pathParts.map((part: string) => part = part.replace(':', ''));
+    this.pathParams = pathParts;
+
+    this.preProcessess = set.preProcessess ? set.preProcessess : [];
+    this.tasks = set.tasks;
+
+    this.logRequest = set.logRequest !== undefined ? set.logRequest : DBE_Global_S.getGlobalSettings().logRequests;
+    this.logRequestsContent = set.logRequestsContent !== undefined ? set.logRequestsContent : DBE_Global_S.getGlobalSettings().logRequestsContent;
+    this.logResponseContent = set.logResponseContent !== undefined ? set.logResponseContent : DBE_Global_S.getGlobalSettings().logResponseContent;
+
+    if (this.logRequest) {
+      this.preProcessess.unshift(this.getPreLog());
+    }
+  }
+
+  getPreLog(): (req: Request, res: Response, next: NextFunction) => Promise<void> {
+    return async (req: Request, res: Response, next: NextFunction) => {
+      if (this.logRequest) {
+        if (this.logRequestsContent) {
+          let inputs = '';
+          for(let i = 0; i < this.pathParams.length; i++) {
+            inputs += ` ${this.pathParams[i]}: ${req.params[this.pathParams[i]]}`;
+            if (i + 1 < this.pathParams.length || req.body && req.body !== {}) {
+              inputs += ',';
+            }
+          }
+
+          if (req.body && 0 < Object.keys(req.body).length) {
+            console.log(`==> incoming ${this.name} request...${inputs} body:`, req.body);
+          } else {
+            console.log(`==> incoming ${this.name} request...${inputs}`);
+          }
+        } else {
+          console.log(`==> incoming ${this.name} request...`);
+        }
+      }
+
+      next();
+    };
+  }
+
+  getTasksExecution(): (req: Request, res: Response) => Promise<void> {
+    return async (req: Request, res: Response) => {
+      try {  
+        const issuer: string = DBE_Global_S.getAuthService().getAccountIdFromRequest(req);
+  
+        await this.tasks.forEach(async (task: (req: Request, res: Response, issuer?: string) => Promise<void>) => {
+          await task(req, res, issuer);
+        });
+  
+        if (this.logRequest) {
+          if (this.logResponseContent) {
+            DBE_Shared.logSuccess(`  <<<=====   ${this.name} result sent.`);
+            DBE_Shared.logSuccess('sorry, the logResponseContent is not implemented yet.');
+          } else {
+            DBE_Shared.logSuccess(`  <<<=====   ${this.name} result sent.`);
+          }
+        }
+      } catch (error) {
+        DBE_Shared.logError(`${this.name} ERROR`, error, '\n');
+        res.status(error.status ? error.status : 501);
+        res.send(error);
+  
+        if (this.logRequest) {
+          if (this.logResponseContent) {
+            DBE_Shared.logError(`  <<<=====   ${this.name} error sent.`);
+            DBE_Shared.logError('sorry, the logResponseContent is not implemented yet.');
+          } else {
+            DBE_Shared.logError(`  <<<=====   ${this.name} error sent.`);
+          }
+        }
+      }
+    };
+  }
+}
+
+
+
+

package/src/_models/dynamobe-global-settings.ts

@@ -0,0 +1,9 @@
+import { DynamoBERouteSecurity } from '../_enum/dynamobe-route-security.enum';
+
+export class DynamoBEGlobalSettings {
+  defaultRouteSecurity?: DynamoBERouteSecurity;
+  logSetup?: boolean;
+  logRequests?: boolean;
+  logRequestsContent?: boolean;
+  logResponseContent?: boolean;
+}

package/src/_models/fullstack-models/control-models/daily-usage-data.ts

@@ -0,0 +1,34 @@
+
+import { DynamoUsageSession } from "../data-models/usage-session";
+
+export class DailyUsageData {
+  date?: string;
+  totalVisitTime?: number = 0;
+  averageVisitTime?: number = 0;
+  visitorsHun?: number = 0;
+  visitorsElse?: number = 0;
+
+  visitations?: DynamoUsageSession[] = [];
+
+  constructor(
+    set?: {
+      date?: string,
+      totalVisitTime?: number,
+      averageVisitTime?: number,
+      visitorsHun?: number,
+      visitorsElse?: number,
+
+      visitations?: DynamoUsageSession[],
+    }
+  ) {
+    if (set) {
+      this.date = set.date;
+      this.totalVisitTime = set.totalVisitTime ? set.totalVisitTime : 0;
+      this.averageVisitTime = set.averageVisitTime ? set.averageVisitTime : 0;
+      this.visitorsHun = set.visitorsHun ? set.visitorsHun : 0;
+      this.visitorsElse = set.visitorsElse ? set.visitorsElse : 0;
+
+      this.visitations = set.visitations ? set.visitations : [];
+    }
+  }
+}

package/src/_models/fullstack-models/control-models/dynamobe-data-property-params.ts

@@ -0,0 +1,98 @@
+
+import { DynamoBEError } from './dynamobe-error';
+
+export class DynamoBEDataPropertyParams {
+  key: string;
+  type: 'string' | 'number' | 'boolean' | 'Date' | 'object' | string;
+
+  unique?: boolean;
+  required?: boolean;
+  index?: boolean;
+
+  isDependencyHook?: boolean;
+  dependencyDBServiceName?: string;
+
+  minlength?: number;
+  maxlength?: number;
+
+  subObjectParams?: DynamoBEDataPropertyParams[] = [];
+
+  additionalValidators?: ((data) => void)[];
+
+  constructor(
+    set: {
+      key: string,
+      type: 'string' | 'number' | 'boolean' | 'Date' | 'object' | string,
+
+      unique?: boolean,
+      required?: boolean,
+      index?: boolean,
+
+      isDependencyHook?: boolean,
+      dependencyDBServiceName?: string,
+
+      minlength?: number,
+      maxlength?: number,
+
+      subObjectParams?: DynamoBEDataPropertyParams[],
+
+      additionalValidators?: ((data) => void)[],
+    }
+  ) {
+
+    if (set) {
+      this.key = set.key;
+      this.type = set.type;
+
+      if (this.getBEType() === Object) {
+        if (set?.subObjectParams) {
+          this.subObjectParams = set.subObjectParams;
+        } else {
+          console.log('DYNAMO ERROR: \n subObjectParams missing', '\n\n', new Error());
+          throw new DynamoBEError({ message: 'subObjectParams missing' });
+        }
+      }
+
+      if (set.isDependencyHook) {
+        if (set.dependencyDBServiceName) {
+          this.isDependencyHook = set.isDependencyHook;
+          this.dependencyDBServiceName = set.dependencyDBServiceName;
+        } else {
+          this.isDependencyHook = set.isDependencyHook;
+          console.log('DYNAMO ERROR: \n dependencyDBServiceName missing for dependencyHook', '\n\n', new Error());
+        }
+      }
+      this.unique = set.unique;
+      this.required = set.required;
+      this.index = set.index;
+      this.minlength = set.minlength;
+      this.maxlength = set.maxlength;
+      this.additionalValidators = set.additionalValidators;
+    } else {
+      console.log('DYNAMO ERROR: \nMISSING DynamoBEDataPropertyParams constructor input', '\n\n', new Error());
+    }
+  }
+
+  // tslint:disable-next-line: ban-types
+  getBEType?(): String | Number | Boolean | Object | Function | Array<any> | Date {
+    switch (this.type) {
+      case 'string':
+        return String;
+      case 'number':
+        return Number;
+      case 'boolean':
+        return Boolean;
+      case 'Date':
+        return Date;
+      case 'object':
+      default:
+        if (this.type.includes('[]')) {
+          return Array;
+        } else if (this.type.includes('=>') || this.type.includes('function')) {
+          return Function;
+        } else {
+          return Object;
+        }
+    }
+  }
+}