@futdevpro/nts-dynamo 1.15.144 → 1.15.145

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

@@ -1,174 +1,174 @@
-
-import { Request, Response } from 'express';
-
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_SingletonService } from '../base/singleton.service';
-import { DyNTS_global_settings } from '../../_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();
- *   }
- *   ...
- */
-export abstract class DyNTS_AuthService extends DyNTS_SingletonService {
-
-  readonly serviceName: string = 'AuthService';
-
-  override readonly 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: Request): string {
-    const authHeader = req?.headers?.['authorization'];
-
-    if (!authHeader) {
-      throw new DyFM_Error({ 
-        status: 401,
-        errorCode: `${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 DyFM_Error({ 
-        status: 401,
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-GT1`,
-        addECToUserMsg: true,
-        message: 'Token missing!', 
-        userMessage: this.defaultErrorUserMsg, 
-        issuerService: this.serviceName,
-        confidentialContent: { headers: req?.headers },
-      });
-    }
-
-    return token;
-  }
-  
-  /**
-   * 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 { DyFM_Error } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_SingletonService } from '../base/singleton.service';
+import { DyNTS_global_settings } from '../../_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();
+ *   }
+ *   ...
+ */
+export abstract class DyNTS_AuthService extends DyNTS_SingletonService {
+
+  readonly serviceName: string = 'AuthService';
+
+  override readonly 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: Request): string {
+    const authHeader = req?.headers?.['authorization'];
+
+    if (!authHeader) {
+      throw new DyFM_Error({ 
+        status: 401,
+        errorCode: `${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 DyFM_Error({ 
+        status: 401,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-GT1`,
+        addECToUserMsg: true,
+        message: 'Token missing!', 
+        userMessage: this.defaultErrorUserMsg, 
+        issuerService: this.serviceName,
+        confidentialContent: { headers: req?.headers },
+      });
+    }
+
+    return token;
+  }
+  
+  /**
+   * 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;
+}

package/src/_services/core/collection-growth-monitor.service.spec.ts

@@ -25,7 +25,7 @@ describe('| DyNTS_CollectionGrowthMonitor.evaluateGrowth (FR-258 / SR-4)', () =>
       DyNTS_CollectionGrowthMonitor.evaluateGrowth('cdp_report_details_archiveds', 300000, undefined, SIZE_THRESHOLD, GROWTH_PCT);
     expect(kinds(alerts)).toEqual(['size']);
     expect(alerts[0].dataName).toBe('cdp_report_details_archiveds');
-    expect(alerts[0].detail).toEqual({ collection: 'cdp_report_details_archiveds', docCount: 300000, threshold: SIZE_THRESHOLD });
+    expect(alerts[0].detail).toEqual({ collection: 'cdp_report_details_archiveds', docCount: 300000, threshold: SIZE_THRESHOLD, retentionDays: null });
   });
 
   it('| exactly AT the threshold → no size alert (strictly greater)', () => {
@@ -65,3 +65,55 @@ describe('| DyNTS_CollectionGrowthMonitor.evaluateGrowth (FR-258 / SR-4)', () =>
     expect(alerts).toEqual([]);
   });
 });
+
+/**
+ * FR-311 spec — a size-riasztas RETENTION-TUDATOS tanacsa.
+ *
+ * MIERT SZAMIT (elesbol jott, 2026-08-19): az overseer `ov_secret_audit` kollekcioja 253 617
+ * dokumentumnal jart, es a monitor azt tanacsolta, hogy "Consider declaring `retention` on this
+ * model" — HOLOTT a modell MAR deklaral `retention: { retentionDays: 365 }`-ot. Az operator tehat
+ * orankent kapott egy olyan feladatot, ami mar KESZ volt, ráadásul az error-tarba is elmentve.
+ *
+ * A ket helyzet KULONBOZO teendot kiván:
+ *   - nincs retention  -> deklaralj egyet,
+ *   - VAN retention    -> az ablak tul hosszu, vagy a novekedes gyorsabb a TTL-nel.
+ */
+describe('| FR-311 — retention-tudatos size-riasztas', () => {
+  const SIZE_T: number = 250000;
+  const GROWTH_P: number = 50;
+
+  it('| retention NELKUL a deklaralasra szolit fel (valtozatlan viselkedes)', () => {
+    const alerts = DyNTS_CollectionGrowthMonitor.evaluateGrowth('logs', 300000, undefined, SIZE_T, GROWTH_P);
+    expect(alerts.length).toBe(1);
+    expect(alerts[0].message).toContain('Consider declaring');
+    expect(alerts[0].detail.retentionDays).toBeNull();
+  });
+
+  /** A VALODI eset: 365 napos retention mellett is 253 617 dokumentum. */
+  it('| deklaralt retention mellett NEM a deklaralast ajanlja, hanem az ablak szukiteset', () => {
+    const alerts = DyNTS_CollectionGrowthMonitor.evaluateGrowth(
+      'ov_secret_audit', 253617, undefined, SIZE_T, GROWTH_P, 365 * 86400,
+    );
+    expect(alerts.length).toBe(1);
+    expect(alerts[0].message).not.toContain('Consider declaring');
+    expect(alerts[0].message).toContain('DESPITE');
+    expect(alerts[0].message).toContain('365 day(s)');
+    expect(alerts[0].detail.retentionDays).toBe(365);
+  });
+
+  it('| a napra kerekites ttlSeconds-bol is helyes', () => {
+    const alerts = DyNTS_CollectionGrowthMonitor.evaluateGrowth('x', 300000, undefined, SIZE_T, GROWTH_P, 14 * 86400);
+    expect(alerts[0].message).toContain('14 day(s)');
+    expect(alerts[0].detail.retentionDays).toBe(14);
+  });
+
+  /** A retention a GROWTH-riasztast nem erinti — az fuggetlen jelzes marad. */
+  it('| a growth-riasztas szoveget a retention NEM valtoztatja', () => {
+    const alerts = DyNTS_CollectionGrowthMonitor.evaluateGrowth(
+      'y', 400000, { docCount: 100000, atMs: 0 }, SIZE_T, GROWTH_P, 30 * 86400,
+    );
+    const growth = alerts.find((a) => a.kind === 'growth');
+    expect(growth).toBeDefined();
+    expect(growth!.message).toContain('fast unbounded growth');
+  });
+});

package/src/_services/core/collection-growth-monitor.service.ts

@@ -1,4 +1,6 @@
-import { DyFM_Error, DyFM_ErrorLevel, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import {
+  DyFM_Error, DyFM_ErrorLevel, DyFM_Log, DyFM_RetentionSettings, DyFM_resolveRetentionTtlSeconds,
+} from '@futdevpro/fsm-dynamo';
 
 import { DyNTS_global_settings } from '../../_collections/global-settings.const';
 import { DyNTS_SingletonServiceBase } from '../base/singleton.service-base';
@@ -113,17 +115,32 @@ export class DyNTS_CollectionGrowthMonitor extends DyNTS_SingletonServiceBase {
     last: CollectionSnapshot | undefined,
     sizeThreshold: number,
     growthRatePct: number,
+    retentionTtlSec?: number,
   ): DyNTS_CollectionGrowthAlert[] {
     const alerts: DyNTS_CollectionGrowthAlert[] = [];
 
     if (count > sizeThreshold) {
+      // FR-311 — RETENTION-TUDATOS tanacs. A korabbi uzenet FELTETEL NELKUL azt ajanlotta, hogy
+      // "declare `retention`" — akkor is, ha a modell MAR deklaralt egyet. Elesben (2026-08-19,
+      // overseer `ov_secret_audit`, 253 617 dokumentum) ez oda vezetett, hogy az operator olyat
+      // kapott feladatul, ami mar KESZ volt, orankent ujra, az error-tarba is elmentve. A ket eset
+      // KULONBOZO teendot kiván, ezert kulon is kell mondani oket.
+      const retentionDays: number | null = retentionTtlSec === undefined
+        ? null
+        : Math.round(retentionTtlSec / 86400);
       alerts.push({
         kind: 'size',
         dataName: dataName,
-        message:
-          `Collection "${dataName}" has ${count} documents (> ${sizeThreshold} threshold) — ` +
-          `unbounded-growth risk. Consider declaring \`retention\` on this model (FR-258 / SR-1).`,
-        detail: { collection: dataName, docCount: count, threshold: sizeThreshold },
+        message: retentionDays === null
+          ? `Collection "${dataName}" has ${count} documents (> ${sizeThreshold} threshold) — ` +
+            `unbounded-growth risk. Consider declaring \`retention\` on this model (FR-258 / SR-1).`
+          : `Collection "${dataName}" has ${count} documents (> ${sizeThreshold} threshold) DESPITE a ` +
+            `declared retention of ~${retentionDays} day(s) — the window is too long, or growth outpaces ` +
+            `the TTL. Shorten \`retention\` or reduce the write-rate (FR-258 / SR-1).`,
+        detail: {
+          collection: dataName, docCount: count, threshold: sizeThreshold,
+          retentionDays: retentionDays,
+        },
       });
     }
 
@@ -163,8 +180,14 @@ export class DyNTS_CollectionGrowthMonitor extends DyNTS_SingletonServiceBase {
           const count: number = await model.estimatedDocumentCount();
           const last: CollectionSnapshot | undefined = this.lastSnapshotByCollection.get(dataName);
 
+          // FR-311 — a modell SAJAT retention-deklaraciojat visszük be a dontesbe. A feloldas az
+          // fsm-dynamo SSOT-resolvereval megy (`ttlSeconds` > `retentionDays`, ervenytelen ertek
+          // elutasitva) — NEM ujraimplementalva, kulonben ketfele igazsag lenne rola.
+          const retentionTtlSec: number | undefined = DyFM_resolveRetentionTtlSeconds(
+            service?.dataParams?.retention as DyFM_RetentionSettings | undefined,
+          );
           const alerts: DyNTS_CollectionGrowthAlert[] = DyNTS_CollectionGrowthMonitor.evaluateGrowth(
-            dataName, count, last, this.sizeThresholdDocCount, this.growthRateThresholdPct,
+            dataName, count, last, this.sizeThresholdDocCount, this.growthRateThresholdPct, retentionTtlSec,
           );
           for (const alert of alerts) {
             this.emitAlert(alert, nowMs);

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

@@ -1,85 +1,85 @@
-
-import { DyFM_Error, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
-import { DyNTS_EmailService, DyNTS_EmailService_Settings, DyNTS_EmailTemplateComponent, DyNTS_SendEmail_Settings } from './email.service';
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
-
-describe('| DyNTS_EmailService', () => {
-  let emailService: DyNTS_EmailService;
-  const settings: DyNTS_EmailService_Settings = {
-    host: 'smtp.example.com',
-    port: 587,
-    email: 'test@example.com',
-    pass: 'password',
-    senderName: 'Test Sender',
-    rootPath: '/path/to/templates',
-    templateComponents: [
-      new DyNTS_EmailTemplateComponent({
-        name: 'testComponent',
-        selector: 'test-selector',
-        template: '<div>{{property}}</div>',
-        properties: [ 'property' ],
-      }),
-    ],
-  };
-
-  beforeAll(() => {
-    if (!DyNTS_global_settings.systemShortCodeName) (DyNTS_global_settings as { systemShortCodeName?: string }).systemShortCodeName = 'TEST';
-    if (!DyNTS_global_settings.env_settings) (DyNTS_global_settings as { env_settings?: unknown }).env_settings = { environment: DyFM_EnvironmentFlag.local };
-  });
-
-  beforeEach(() => {
-    (DyNTS_global_settings as { env_settings: unknown }).env_settings = {
-      environment: DyFM_EnvironmentFlag.local,
-      mongoUri: 'mongodb://localhost:27017/test',
-      discord: undefined,
-      openAi: undefined,
-    };
-
-    emailService = new DyNTS_EmailService(settings);
-  });
-
-  it('| should initialize with correct settings', () => {
-    expect(emailService.serviceName).toBe('DyNTS_EmailService');
-    expect(emailService['senderName']).toBe(settings.senderName);
-    expect(emailService['senderNEmail']).toBe(`${settings.senderName} <${settings.email}>`);
-  });
-
-  it('| should load email template components', async () => {
-    await emailService.asyncPostConstruct();
-    expect(emailService['componentsByName']['testComponent']).toBeDefined();
-    expect(emailService['componentsBySelector']['test-selector']).toBeDefined();
-  });
-
-  it('| should throw error if no template component name is provided', async () => {
-    const sendEmailSettings: DyNTS_SendEmail_Settings = {
-      to: 'recipient@example.com',
-      subject: 'Test Subject',
-    };
-
-    await expectAsync(emailService.sendEmail(sendEmailSettings, 'testIssuer'))
-      .toBeRejectedWith(jasmine.any(DyFM_Error));
-  });
-
-  it('| should throw error if template component is not found', async () => {
-    const sendEmailSettings: DyNTS_SendEmail_Settings = {
-      to: 'recipient@example.com',
-      subject: 'Test Subject',
-      templateComponentName: 'nonExistentComponent',
-    };
-
-    await expectAsync(emailService.sendEmail(sendEmailSettings, 'testIssuer'))
-      .toBeRejectedWith(jasmine.any(DyFM_Error));
-  });
-
-  it('| should throw error if template property is missing', async () => {
-    const component = new DyNTS_EmailTemplateComponent({
-      name: 'testComponent',
-      selector: 'test-selector',
-      template: '<div>{{missingProperty}}</div>',
-      properties: [ 'missingProperty' ],
-    });
-
-    await expectAsync(emailService['compileComponentProperties'](component, {}, '', 'testIssuer'))
-      .toBeRejectedWith(jasmine.any(DyFM_Error));
-  });
-});
+
+import { DyFM_Error, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
+import { DyNTS_EmailService, DyNTS_EmailService_Settings, DyNTS_EmailTemplateComponent, DyNTS_SendEmail_Settings } from './email.service';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+describe('| DyNTS_EmailService', () => {
+  let emailService: DyNTS_EmailService;
+  const settings: DyNTS_EmailService_Settings = {
+    host: 'smtp.example.com',
+    port: 587,
+    email: 'test@example.com',
+    pass: 'password',
+    senderName: 'Test Sender',
+    rootPath: '/path/to/templates',
+    templateComponents: [
+      new DyNTS_EmailTemplateComponent({
+        name: 'testComponent',
+        selector: 'test-selector',
+        template: '<div>{{property}}</div>',
+        properties: [ 'property' ],
+      }),
+    ],
+  };
+
+  beforeAll(() => {
+    if (!DyNTS_global_settings.systemShortCodeName) (DyNTS_global_settings as { systemShortCodeName?: string }).systemShortCodeName = 'TEST';
+    if (!DyNTS_global_settings.env_settings) (DyNTS_global_settings as { env_settings?: unknown }).env_settings = { environment: DyFM_EnvironmentFlag.local };
+  });
+
+  beforeEach(() => {
+    (DyNTS_global_settings as { env_settings: unknown }).env_settings = {
+      environment: DyFM_EnvironmentFlag.local,
+      mongoUri: 'mongodb://localhost:27017/test',
+      discord: undefined,
+      openAi: undefined,
+    };
+
+    emailService = new DyNTS_EmailService(settings);
+  });
+
+  it('| should initialize with correct settings', () => {
+    expect(emailService.serviceName).toBe('DyNTS_EmailService');
+    expect(emailService['senderName']).toBe(settings.senderName);
+    expect(emailService['senderNEmail']).toBe(`${settings.senderName} <${settings.email}>`);
+  });
+
+  it('| should load email template components', async () => {
+    await emailService.asyncPostConstruct();
+    expect(emailService['componentsByName']['testComponent']).toBeDefined();
+    expect(emailService['componentsBySelector']['test-selector']).toBeDefined();
+  });
+
+  it('| should throw error if no template component name is provided', async () => {
+    const sendEmailSettings: DyNTS_SendEmail_Settings = {
+      to: 'recipient@example.com',
+      subject: 'Test Subject',
+    };
+
+    await expectAsync(emailService.sendEmail(sendEmailSettings, 'testIssuer'))
+      .toBeRejectedWith(jasmine.any(DyFM_Error));
+  });
+
+  it('| should throw error if template component is not found', async () => {
+    const sendEmailSettings: DyNTS_SendEmail_Settings = {
+      to: 'recipient@example.com',
+      subject: 'Test Subject',
+      templateComponentName: 'nonExistentComponent',
+    };
+
+    await expectAsync(emailService.sendEmail(sendEmailSettings, 'testIssuer'))
+      .toBeRejectedWith(jasmine.any(DyFM_Error));
+  });
+
+  it('| should throw error if template property is missing', async () => {
+    const component = new DyNTS_EmailTemplateComponent({
+      name: 'testComponent',
+      selector: 'test-selector',
+      template: '<div>{{missingProperty}}</div>',
+      properties: [ 'missingProperty' ],
+    });
+
+    await expectAsync(emailService['compileComponentProperties'](component, {}, '', 'testIssuer'))
+      .toBeRejectedWith(jasmine.any(DyFM_Error));
+  });
+});