@futdevpro/nts-dynamo 1.15.64 → 1.15.68

package/build/_services/core/auth.service.d.ts

@@ -1,130 +1,130 @@
-import { Request, Response } from 'express';
-import { DyNTS_SingletonService } from '../base/singleton.service';
-/**
- * Extend this class as an Auth Service implementation
- *
- * You should use singleton instance getting function by implementing a
- * static getInstance() function
- * @example
- * export class AuthService extends DyNTS_AuthService {
- *
- *   static getInstance(): AuthService {
- *     return AuthService.getSingletonInstance();
- *   }
- *   ...
- */
-export declare abstract class DyNTS_AuthService extends DyNTS_SingletonService {
-    readonly serviceName: string;
-    readonly defaultErrorUserMsg: string;
-    /**
-     * this function returns the 'authorization' header from the Request,
-     * or throws error, if its missing
-     *
-     * @param req
-     * @returns
-     */
-    getTokenFromRequest(req: Request): string;
-    /**
-     * You need to implement a token validation logic,
-     * when if the token is invalid, or the authentication fails, it sends or throws an error
-     *
-     * @example
-     *
-     * async authenticateToken(req: Request, res: Response, next: NextFunction) {
-     *   try {
-     *     let token = AuthService.getTokenFromRequest(req);
-     *     token = await AuthService.verifyToken(token);
-     *
-     *     DyFM_Log.success('token authenticated');
-     *     res.setHeader('authorization', `Bearer ${token}`);
-     *     next();
-     *   } catch (error) {
-     *     error = new DyFM_Error({
-     *       status: 401,
-     *       message: `authenticateToken (WB-ERROR)`,
-     *       addECToUserMsg: true,
-     *       userMessage: `Authorization failed.`,
-     *       error
-     *     });
-     *     DyFM_Log.error(error?.message, error);
-     *
-     *     res.status(error.status);
-     *     res.send(error);
-     *   }
-     * }
-     * */
-    abstract authenticate_token: (req: Request, res: Response) => Promise<void>;
-    /**
-     * You need to implement a token validation logic,
-     * when if the token is invalid, or the authentication fails, it sends or throws an error
-     *
-     * @param req
-     * @param res
-     * @param next
-     *
-     * @example
-     *
-     * async authenticate_tokenSelf(req: Request, res: Response, next: NextFunction): Promise<void> {
-     *   try {
-     *     let token = AuthService.getTokenFromRequest(req);
-     *     token = await AuthService.verifyTokenSelf(token, req?.params?.userId);
-     *     DyFM_Log.success('selftoken authenticated');
-     *
-     *     res.setHeader('authorization', `Bearer ${token}`);
-     *     next();
-     *   } catch (error) {
-     *     error = new DyFM_Error({
-     *       status: 401,
-     *       message: `authenticate_tokenSelf (WB-ERROR)`,
-     *       addECToUserMsg: true,
-     *       userMessage: `Authorization failed.`,
-     *       error
-     *     });
-     *     DyFM_Log.error(error?.message, error);
-     *
-     *     res.status(error.status);
-     *     res.send(error);
-     *   }
-     * }
-     *
-     */
-    abstract authenticate_tokenSelf: (req: Request, res: Response) => Promise<void>;
-    /**
-     * Authenticate Token for Permission to Access UsageData
-     * @param req
-     * @param res
-     * @param next
-     *
-     * @example
-     * You need to implement a token validation logic,
-     * when if the token is invalid, or the authentication fails, it sends or throws an error
-     *
-     * async authTokenPermAccUsageData(req: Request, res: Response, next: NextFunction): Promise<void> {
-     *   AuthService.authTokenAndPerm(req, res, next, Permission.accessUsageData);
-     * }
-     */
-    abstract authenticate_tokenPerm_accUsageData: (req: Request, res: Response) => Promise<void>;
-    /**
-     * The DynamoNTS System is using this to get issuer, that will be set on DBServices
-     * Don't throw error in this function, since it will be used in every request
-     * @param req
-     *
-     * @example
-     * getAccountIdFromRequest(req: Request): string {
-     *   try {
-     *     const authHeader = req.headers['authorization'];
-     *     const token = authHeader.split(' ')[1];
-     *     return this.getAccountIdFromToken(token);
-     *   } catch {
-     *     return undefined;
-     *   }
-     * }
-     */
-    abstract getIssuerFromRequest(req: Request): string;
-    /**
-     * Basic Module: UsageModule uses this function
-     * @param req
-     */
-    abstract getUsernameFromRequest(req: Request): string;
-}
+import { Request, Response } from 'express';
+import { DyNTS_SingletonService } from '../base/singleton.service';
+/**
+ * Extend this class as an Auth Service implementation
+ *
+ * You should use singleton instance getting function by implementing a
+ * static getInstance() function
+ * @example
+ * export class AuthService extends DyNTS_AuthService {
+ *
+ *   static getInstance(): AuthService {
+ *     return AuthService.getSingletonInstance();
+ *   }
+ *   ...
+ */
+export declare abstract class DyNTS_AuthService extends DyNTS_SingletonService {
+    readonly serviceName: string;
+    readonly defaultErrorUserMsg: string;
+    /**
+     * this function returns the 'authorization' header from the Request,
+     * or throws error, if its missing
+     *
+     * @param req
+     * @returns
+     */
+    getTokenFromRequest(req: Request): string;
+    /**
+     * You need to implement a token validation logic,
+     * when if the token is invalid, or the authentication fails, it sends or throws an error
+     *
+     * @example
+     *
+     * async authenticateToken(req: Request, res: Response, next: NextFunction) {
+     *   try {
+     *     let token = AuthService.getTokenFromRequest(req);
+     *     token = await AuthService.verifyToken(token);
+     *
+     *     DyFM_Log.success('token authenticated');
+     *     res.setHeader('authorization', `Bearer ${token}`);
+     *     next();
+     *   } catch (error) {
+     *     error = new DyFM_Error({
+     *       status: 401,
+     *       message: `authenticateToken (WB-ERROR)`,
+     *       addECToUserMsg: true,
+     *       userMessage: `Authorization failed.`,
+     *       error
+     *     });
+     *     DyFM_Log.error(error?.message, error);
+     *
+     *     res.status(error.status);
+     *     res.send(error);
+     *   }
+     * }
+     * */
+    abstract authenticate_token: (req: Request, res: Response) => Promise<void>;
+    /**
+     * You need to implement a token validation logic,
+     * when if the token is invalid, or the authentication fails, it sends or throws an error
+     *
+     * @param req
+     * @param res
+     * @param next
+     *
+     * @example
+     *
+     * async authenticate_tokenSelf(req: Request, res: Response, next: NextFunction): Promise<void> {
+     *   try {
+     *     let token = AuthService.getTokenFromRequest(req);
+     *     token = await AuthService.verifyTokenSelf(token, req?.params?.userId);
+     *     DyFM_Log.success('selftoken authenticated');
+     *
+     *     res.setHeader('authorization', `Bearer ${token}`);
+     *     next();
+     *   } catch (error) {
+     *     error = new DyFM_Error({
+     *       status: 401,
+     *       message: `authenticate_tokenSelf (WB-ERROR)`,
+     *       addECToUserMsg: true,
+     *       userMessage: `Authorization failed.`,
+     *       error
+     *     });
+     *     DyFM_Log.error(error?.message, error);
+     *
+     *     res.status(error.status);
+     *     res.send(error);
+     *   }
+     * }
+     *
+     */
+    abstract authenticate_tokenSelf: (req: Request, res: Response) => Promise<void>;
+    /**
+     * Authenticate Token for Permission to Access UsageData
+     * @param req
+     * @param res
+     * @param next
+     *
+     * @example
+     * You need to implement a token validation logic,
+     * when if the token is invalid, or the authentication fails, it sends or throws an error
+     *
+     * async authTokenPermAccUsageData(req: Request, res: Response, next: NextFunction): Promise<void> {
+     *   AuthService.authTokenAndPerm(req, res, next, Permission.accessUsageData);
+     * }
+     */
+    abstract authenticate_tokenPerm_accUsageData: (req: Request, res: Response) => Promise<void>;
+    /**
+     * The DynamoNTS System is using this to get issuer, that will be set on DBServices
+     * Don't throw error in this function, since it will be used in every request
+     * @param req
+     *
+     * @example
+     * getAccountIdFromRequest(req: Request): string {
+     *   try {
+     *     const authHeader = req.headers['authorization'];
+     *     const token = authHeader.split(' ')[1];
+     *     return this.getAccountIdFromToken(token);
+     *   } catch {
+     *     return undefined;
+     *   }
+     * }
+     */
+    abstract getIssuerFromRequest(req: Request): string;
+    /**
+     * Basic Module: UsageModule uses this function
+     * @param req
+     */
+    abstract getUsernameFromRequest(req: Request): string;
+}
 //# sourceMappingURL=auth.service.d.ts.map

package/build/_services/core/auth.service.js

@@ -1,60 +1,60 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyNTS_AuthService = void 0;
-const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
-const singleton_service_1 = require("../base/singleton.service");
-const global_settings_const_1 = require("../../_collections/global-settings.const");
-/**
- * Extend this class as an Auth Service implementation
- *
- * You should use singleton instance getting function by implementing a
- * static getInstance() function
- * @example
- * export class AuthService extends DyNTS_AuthService {
- *
- *   static getInstance(): AuthService {
- *     return AuthService.getSingletonInstance();
- *   }
- *   ...
- */
-class DyNTS_AuthService extends singleton_service_1.DyNTS_SingletonService {
-    serviceName = 'AuthService';
-    defaultErrorUserMsg = `We encountered an unhandled Auth Error, ` +
-        `\nplease contact the responsible development team.`;
-    /**
-     * this function returns the 'authorization' header from the Request,
-     * or throws error, if its missing
-     *
-     * @param req
-     * @returns
-     */
-    getTokenFromRequest(req) {
-        const authHeader = req?.headers?.['authorization'];
-        if (!authHeader) {
-            throw new fsm_dynamo_1.DyFM_Error({
-                status: 401,
-                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-GT0`,
-                addECToUserMsg: true,
-                message: 'AuthHeader missing!',
-                userMessage: this.defaultErrorUserMsg,
-                issuerService: this.serviceName,
-                confidentialContent: { headers: req?.headers },
-            });
-        }
-        const token = authHeader.split(' ')[1];
-        if (!token) {
-            throw new fsm_dynamo_1.DyFM_Error({
-                status: 401,
-                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-GT1`,
-                addECToUserMsg: true,
-                message: 'Token missing!',
-                userMessage: this.defaultErrorUserMsg,
-                issuerService: this.serviceName,
-                confidentialContent: { headers: req?.headers },
-            });
-        }
-        return token;
-    }
-}
-exports.DyNTS_AuthService = DyNTS_AuthService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyNTS_AuthService = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const singleton_service_1 = require("../base/singleton.service");
+const global_settings_const_1 = require("../../_collections/global-settings.const");
+/**
+ * Extend this class as an Auth Service implementation
+ *
+ * You should use singleton instance getting function by implementing a
+ * static getInstance() function
+ * @example
+ * export class AuthService extends DyNTS_AuthService {
+ *
+ *   static getInstance(): AuthService {
+ *     return AuthService.getSingletonInstance();
+ *   }
+ *   ...
+ */
+class DyNTS_AuthService extends singleton_service_1.DyNTS_SingletonService {
+    serviceName = 'AuthService';
+    defaultErrorUserMsg = `We encountered an unhandled Auth Error, ` +
+        `\nplease contact the responsible development team.`;
+    /**
+     * this function returns the 'authorization' header from the Request,
+     * or throws error, if its missing
+     *
+     * @param req
+     * @returns
+     */
+    getTokenFromRequest(req) {
+        const authHeader = req?.headers?.['authorization'];
+        if (!authHeader) {
+            throw new fsm_dynamo_1.DyFM_Error({
+                status: 401,
+                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-GT0`,
+                addECToUserMsg: true,
+                message: 'AuthHeader missing!',
+                userMessage: this.defaultErrorUserMsg,
+                issuerService: this.serviceName,
+                confidentialContent: { headers: req?.headers },
+            });
+        }
+        const token = authHeader.split(' ')[1];
+        if (!token) {
+            throw new fsm_dynamo_1.DyFM_Error({
+                status: 401,
+                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-GT1`,
+                addECToUserMsg: true,
+                message: 'Token missing!',
+                userMessage: this.defaultErrorUserMsg,
+                issuerService: this.serviceName,
+                confidentialContent: { headers: req?.headers },
+            });
+        }
+        return token;
+    }
+}
+exports.DyNTS_AuthService = DyNTS_AuthService;
 //# sourceMappingURL=auth.service.js.map

package/build/_services/core/email.service.d.ts

@@ -1,78 +1,78 @@
-import { Attachment } from 'nodemailer/lib/mailer';
-import { DyFM_AnyError, DyFM_Error_Settings } from '@futdevpro/fsm-dynamo';
-export interface DyNTS_EmailService_Settings {
-    host: string;
-    port: number;
-    email: string;
-    pass: string;
-    senderName: string;
-    rootPath: string;
-    templateComponents?: DyNTS_EmailTemplateComponent[];
-}
-export declare class DyNTS_EmailTemplateComponent {
-    name: string;
-    selector: string;
-    templatePath?: string;
-    template?: string;
-    stylePath?: string;
-    styles?: string;
-    headerLinks?: string;
-    properties?: string[];
-    subComponentSelectors?: string[];
-    constructor(set?: DyNTS_EmailTemplateComponent);
-}
-export interface DyNTS_SendEmail_Settings<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[];
-}
-/**
- *
- */
-export declare class DyNTS_EmailService {
-    serviceName: string;
-    private readonly nmTransporter;
-    private readonly senderName;
-    private readonly senderNEmail;
-    private readonly components;
-    private readonly componentsBySelector;
-    private readonly componentsByName;
-    private readonly styleLimitWarning;
-    readonly defaultErrorUserMsg: string;
-    constructor(set: DyNTS_EmailService_Settings);
-    asyncPostConstruct(): Promise<void>;
-    /**
-     *
-     * @param set
-     */
-    sendEmail<T>(set: DyNTS_SendEmail_Settings<T>, issuer: string): Promise<void>;
-    private compileTemplateComponent;
-    private compileHTMLMainFrame;
-    /** trims all rows and remove everything between /*...*\/  */
-    private styleTrim;
-    /** removes HTML comments */
-    private templateTrim;
-    private getStringKBSize;
-    private compileComponentProperties;
-    private compileSubComponent;
-    private loadEmailTemplateComponent;
-    private readFile;
-    private connectComponents;
-    /**
-     *
-     * @param template
-     * @returns
-     */
-    private getTemplatePropertyKeys;
-    private _getDefaultErrorSettings;
-    protected getDefaultErrorSettings(fnName: string, error: DyFM_AnyError, issuer: string, 
-    /** @deprecated we wont support the separate user message in the future, use the message instead */
-    useMessageAsUserMessage?: boolean): DyFM_Error_Settings;
-}
+import { Attachment } from 'nodemailer/lib/mailer';
+import { DyFM_AnyError, DyFM_Error_Settings } from '@futdevpro/fsm-dynamo';
+export interface DyNTS_EmailService_Settings {
+    host: string;
+    port: number;
+    email: string;
+    pass: string;
+    senderName: string;
+    rootPath: string;
+    templateComponents?: DyNTS_EmailTemplateComponent[];
+}
+export declare class DyNTS_EmailTemplateComponent {
+    name: string;
+    selector: string;
+    templatePath?: string;
+    template?: string;
+    stylePath?: string;
+    styles?: string;
+    headerLinks?: string;
+    properties?: string[];
+    subComponentSelectors?: string[];
+    constructor(set?: DyNTS_EmailTemplateComponent);
+}
+export interface DyNTS_SendEmail_Settings<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[];
+}
+/**
+ *
+ */
+export declare class DyNTS_EmailService {
+    serviceName: string;
+    private readonly nmTransporter;
+    private readonly senderName;
+    private readonly senderNEmail;
+    private readonly components;
+    private readonly componentsBySelector;
+    private readonly componentsByName;
+    private readonly styleLimitWarning;
+    readonly defaultErrorUserMsg: string;
+    constructor(set: DyNTS_EmailService_Settings);
+    asyncPostConstruct(): Promise<void>;
+    /**
+     *
+     * @param set
+     */
+    sendEmail<T>(set: DyNTS_SendEmail_Settings<T>, issuer: string): Promise<void>;
+    private compileTemplateComponent;
+    private compileHTMLMainFrame;
+    /** trims all rows and remove everything between /*...*\/  */
+    private styleTrim;
+    /** removes HTML comments */
+    private templateTrim;
+    private getStringKBSize;
+    private compileComponentProperties;
+    private compileSubComponent;
+    private loadEmailTemplateComponent;
+    private readFile;
+    private connectComponents;
+    /**
+     *
+     * @param template
+     * @returns
+     */
+    private getTemplatePropertyKeys;
+    private _getDefaultErrorSettings;
+    protected getDefaultErrorSettings(fnName: string, error: DyFM_AnyError, issuer: string, 
+    /** @deprecated we wont support the separate user message in the future, use the message instead */
+    useMessageAsUserMessage?: boolean): DyFM_Error_Settings;
+}
 //# sourceMappingURL=email.service.d.ts.map