@futdevpro/nts-dynamo 1.15.157 → 1.15.160

package/src/_services/core/db-stats.service.ts

@@ -1,104 +0,0 @@
-import * as mongoose from 'mongoose';
-
-import { DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-/**
- * BFR-OVERSEER-004 — stats-only DB-diagnosztika (NO direct data read).
- *
- * Per-collection rekordszám + adat-méret + index-méret (a `$collStats` aggregation-stage-en át —
- * metaadat-olvasás, SOHA nem dokumentum-tartalom) + összesített DB-méret. A 2026-06-23 overseer-incidens
- * (3 GB-ra hízott archív-collection, csak kézi mongosh-sal látszott) proaktív early-warningja: minden
- * NTS-szerver default megkapja a `/server/db-stats` endpointon (app-auth-tal gate-elhető).
- */
-
-export interface DyNTS_CollectionStats {
-  name: string;
-  documentCount: number;
-  sizeMB: number;
-  indexSizeMB: number;
-}
-
-export interface DyNTS_DbStats {
-  dbName: string;
-  collections: DyNTS_CollectionStats[];
-  totalSizeMB: number;
-  totalIndexSizeMB: number;
-  totalDocumentCount: number;
-  /** A gyűjtés közben elhasalt collection-ök (never-silent — a kihagyás látható). */
-  failedCollections: string[];
-}
-
-const BYTES_PER_MB: number = 1024 * 1024;
-
-export class DyNTS_DbStats_Util {
-
-  /**
-   * A teljes stats-only pillanatkép. Hibatűrő: egy-egy collection statjának elhasalása NEM
-   * borítja a többit (failedCollections-be kerül, warn-nal — no-silent-skip).
-   */
-  static async collect(connection: mongoose.Connection): Promise<DyNTS_DbStats> {
-    const db: typeof connection.db = connection?.db;
-    if (!db) {
-      return {
-        dbName: connection?.name ?? '-no-connection-',
-        collections: [],
-        totalSizeMB: 0,
-        totalIndexSizeMB: 0,
-        totalDocumentCount: 0,
-        failedCollections: [],
-      };
-    }
-
-    const collectionInfos: { name: string }[] = await db.listCollections({}, { nameOnly: true }).toArray();
-    const collections: DyNTS_CollectionStats[] = [];
-    const failedCollections: string[] = [];
-
-    for (const info of collectionInfos) {
-      try {
-        // $collStats storageStats: metaadat-only (size/count/totalIndexSize) — nincs dokumentum-olvasás.
-        const statsCursor = db.collection(info.name).aggregate([
-          { $collStats: { storageStats: {} } },
-        ]);
-        const statsDocs: Record<string, unknown>[] = await statsCursor.toArray();
-        const storage: Record<string, unknown> =
-          (statsDocs[0]?.['storageStats'] ?? {}) as Record<string, unknown>;
-
-        collections.push({
-          name: info.name,
-          documentCount: Number(storage['count'] ?? 0),
-          sizeMB: DyNTS_DbStats_Util.toMB(Number(storage['size'] ?? 0)),
-          indexSizeMB: DyNTS_DbStats_Util.toMB(Number(storage['totalIndexSize'] ?? 0)),
-        });
-      } catch (error) {
-        failedCollections.push(info.name);
-        DyFM_Log.warn(`(DyNTS_DbStats) collStats failed for "${info.name}" (non-fatal)`, error);
-      }
-    }
-
-    // Méret szerint csökkenő — a bloat-gyanús collection legyen elöl.
-    collections.sort((a: DyNTS_CollectionStats, b: DyNTS_CollectionStats): number => b.sizeMB - a.sizeMB);
-
-    return {
-      dbName: connection.name,
-      collections: collections,
-      totalSizeMB: DyNTS_DbStats_Util.round2(
-        collections.reduce((sum: number, c: DyNTS_CollectionStats): number => sum + c.sizeMB, 0)
-      ),
-      totalIndexSizeMB: DyNTS_DbStats_Util.round2(
-        collections.reduce((sum: number, c: DyNTS_CollectionStats): number => sum + c.indexSizeMB, 0)
-      ),
-      totalDocumentCount: collections.reduce(
-        (sum: number, c: DyNTS_CollectionStats): number => sum + c.documentCount, 0
-      ),
-      failedCollections: failedCollections,
-    };
-  }
-
-  static toMB(bytes: number): number {
-    return DyNTS_DbStats_Util.round2(bytes / BYTES_PER_MB);
-  }
-
-  static round2(value: number): number {
-    return Math.round(value * 100) / 100;
-  }
-}

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

@@ -1,44 +0,0 @@
-import { DyNTS_DbStats_Util } from './db-stats.service';
-import { DyNTS_Diagnostics, DyNTS_DoctorCheck } from './diagnostics.service';
-
-/**
- * BFR-AM-015 / BFR-OVERSEER-004 — a diagnosztika PURE részeinek unit-tesztjei
- * (interpretHealth / buildSummary / MB-kerekítés).
- */
-describe('| DyNTS_Diagnostics (pure)', () => {
-
-  const ok: DyNTS_DoctorCheck = { name: 'a', health: 'ok' };
-  const warn: DyNTS_DoctorCheck = { name: 'b', health: 'warn', fixHint: 'do b' };
-  const fail: DyNTS_DoctorCheck = { name: 'c', health: 'fail', fixHint: 'do c' };
-
-  it('| interpretHealth: fail dominál, aztán warn, különben ok', () => {
-    expect(DyNTS_Diagnostics.interpretHealth([ ok, ok ])).toBe('ok');
-    expect(DyNTS_Diagnostics.interpretHealth([ ok, warn ])).toBe('warn');
-    expect(DyNTS_Diagnostics.interpretHealth([ warn, fail, ok ])).toBe('fail');
-    expect(DyNTS_Diagnostics.interpretHealth([])).toBe('ok');
-  });
-
-  it('| buildSummary: all-ok → "all checks ok"; nem-ok check-ek fixHint-tel listázva', () => {
-    expect(DyNTS_Diagnostics.buildSummary([ ok ])).toBe('all checks ok');
-    const summary: string = DyNTS_Diagnostics.buildSummary([ ok, warn, fail ]);
-    expect(summary).toContain('b: warn — do b');
-    expect(summary).toContain('c: fail — do c');
-    expect(summary).not.toContain('a:');
-  });
-});
-
-describe('| DyNTS_DbStats_Util (pure)', () => {
-
-  it('| toMB: byte → MB két tizedesre', () => {
-    expect(DyNTS_DbStats_Util.toMB(1024 * 1024)).toBe(1);
-    expect(DyNTS_DbStats_Util.toMB(1536 * 1024)).toBe(1.5);
-    expect(DyNTS_DbStats_Util.toMB(0)).toBe(0);
-  });
-
-  it('| collect: kapcsolat nélkül üres, nem-dobó eredmény', async () => {
-    const stats = await DyNTS_DbStats_Util.collect(undefined as never);
-    expect(stats.collections).toEqual([]);
-    expect(stats.totalSizeMB).toBe(0);
-    expect(stats.failedCollections).toEqual([]);
-  });
-});

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

@@ -1,158 +0,0 @@
-import * as mongoose from 'mongoose';
-
-import { DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_DbStats, DyNTS_DbStats_Util } from './db-stats.service';
-import { DyNTS_EventLoopDiag } from './event-loop-diag.service';
-import { DyNTS_MemoryGuard } from './memory-guard.service';
-
-/**
- * BFR-AM-015 (+ BFR-OVERSEER-004 aggregátor-fele) — generikus, újrahasználható diagnosztikai
- * aggregátor MINDEN `DyNTS_App`-hoz: a `GET /server/doctor` endpoint forrása.
- *
- * Check-ek (mind SAJÁT try-ban — egy elhasaló check nem borítja a doctort, néma hiba TILOS):
- *  - mongo: kapcsolat + ping (readiness-minta);
- *  - memory: MemoryGuard pressure-snapshot;
- *  - eventLoop: EventLoopDiag snapshot;
- *  - dbStats: stats-only collection-méretek + küszöb-warn a bloat-gyanúra.
- * Az app APP-SPECIFIKUS check-eket regisztrálhat (`registerCheck`) — pl. env-validáció,
- * provider-probe (a FAM `FAM_Doctor` mintája bedrock-magként).
- */
-
-export interface DyNTS_DoctorCheck {
-  name: string;
-  health: 'ok' | 'warn' | 'fail';
-  detail?: unknown;
-  /** Mit tegyen az operátor, ha nem ok (néma hiba tilos — a hint kötelező nem-ok esetén). */
-  fixHint?: string;
-}
-
-export interface DyNTS_DoctorReport {
-  health: 'ok' | 'warn' | 'fail';
-  checks: DyNTS_DoctorCheck[];
-  summary: string;
-  uptimeSec: number;
-}
-
-/** App-specifikus check-függvény (a doctor futtatja, saját try-ban). */
-export type DyNTS_DoctorCheckFn = () => Promise<DyNTS_DoctorCheck>;
-
-/** Collection-méret warn-küszöb (MB) — e fölött a dbStats-check warn-ra vált. */
-const DEFAULT_COLLECTION_WARN_MB: number = 512;
-
-export class DyNTS_Diagnostics {
-
-  private static readonly customChecks: DyNTS_DoctorCheckFn[] = [];
-
-  /** App-specifikus check regisztrálása (pl. env-validáció, provider-probe). */
-  static registerCheck(check: DyNTS_DoctorCheckFn): void {
-    DyNTS_Diagnostics.customChecks.push(check);
-  }
-
-  /** A teljes doctor-riport. SOSEM dob — a hibás check `fail`-ként jelenik meg. */
-  static async runDoctor(set: {
-    connection: mongoose.Connection,
-    collectionWarnMB?: number,
-  }): Promise<DyNTS_DoctorReport> {
-    const checks: DyNTS_DoctorCheck[] = [];
-
-    // 1) Mongo-probe (readiness-minta: readyState + admin ping).
-    try {
-      const readyState: number = set.connection?.readyState ?? 0;
-      let pingOk: boolean = false;
-      if (readyState === 1) {
-        await set.connection.db?.admin().ping();
-        pingOk = true;
-      }
-      checks.push({
-        name: 'mongo',
-        health: readyState === 1 && pingOk ? 'ok' : 'fail',
-        detail: { readyState: readyState, pingOk: pingOk },
-        fixHint: readyState === 1 && pingOk ? undefined
-          : 'Check MONGO_URL + DB container/network reachability (readyState 1 + ping expected).',
-      });
-    } catch (error) {
-      checks.push({
-        name: 'mongo', health: 'fail', detail: String(error),
-        fixHint: 'Mongo ping threw — check DB availability/credentials.',
-      });
-    }
-
-    // 2) Memória (MemoryGuard pressure).
-    try {
-      const pressure: unknown = DyNTS_MemoryGuard.getInstance().pressure();
-      const level: string = String((pressure as { level?: string })?.level ?? 'ok');
-      checks.push({
-        name: 'memory',
-        health: level === 'critical' ? 'fail' : level === 'warning' ? 'warn' : 'ok',
-        detail: pressure,
-        fixHint: level === 'ok' ? undefined
-          : 'Heap pressure — check collection sizes (/server/db-stats) + recent load; consider retention.',
-      });
-    } catch (error) {
-      checks.push({ name: 'memory', health: 'warn', detail: String(error), fixHint: 'MemoryGuard snapshot failed.' });
-    }
-
-    // 3) Event-loop lag.
-    try {
-      const snapshot: unknown = DyNTS_EventLoopDiag.getInstance().getSnapshot();
-      checks.push({ name: 'eventLoop', health: 'ok', detail: snapshot });
-    } catch (error) {
-      checks.push({ name: 'eventLoop', health: 'warn', detail: String(error), fixHint: 'EventLoopDiag snapshot failed.' });
-    }
-
-    // 4) DB-stats + bloat-küszöb (BFR-OVERSEER-004 early-warning).
-    try {
-      const stats: DyNTS_DbStats = await DyNTS_DbStats_Util.collect(set.connection);
-      const warnMB: number = set.collectionWarnMB ?? DEFAULT_COLLECTION_WARN_MB;
-      const bloated: string[] = stats.collections
-        .filter((c): boolean => c.sizeMB + c.indexSizeMB > warnMB)
-        .map((c): string => `${c.name} (${c.sizeMB}MB + ${c.indexSizeMB}MB idx)`);
-      checks.push({
-        name: 'dbStats',
-        health: bloated.length ? 'warn' : 'ok',
-        detail: { totalSizeMB: stats.totalSizeMB, collectionCount: stats.collections.length, bloated: bloated },
-        fixHint: bloated.length
-          ? `Collections over ${warnMB}MB — add dataParams.retention (TTL) or prune: ${bloated.join(', ')}`
-          : undefined,
-      });
-    } catch (error) {
-      checks.push({ name: 'dbStats', health: 'warn', detail: String(error), fixHint: 'db-stats collection failed.' });
-    }
-
-    // 5) App-specifikus check-ek.
-    for (const customCheck of DyNTS_Diagnostics.customChecks) {
-      try {
-        checks.push(await customCheck());
-      } catch (error) {
-        DyFM_Log.warn('(DyNTS_Diagnostics) custom check threw (reported as fail)', error);
-        checks.push({ name: 'custom', health: 'fail', detail: String(error), fixHint: 'Custom check threw — see detail.' });
-      }
-    }
-
-    return {
-      health: DyNTS_Diagnostics.interpretHealth(checks),
-      checks: checks,
-      summary: DyNTS_Diagnostics.buildSummary(checks),
-      uptimeSec: Math.round(process.uptime()),
-    };
-  }
-
-  /** Aggregált health: bármely fail → fail; különben bármely warn → warn; különben ok. Pure (unit-tesztelt). */
-  static interpretHealth(checks: DyNTS_DoctorCheck[]): 'ok' | 'warn' | 'fail' {
-    if (checks.some((c: DyNTS_DoctorCheck): boolean => c.health === 'fail')) { return 'fail'; }
-    if (checks.some((c: DyNTS_DoctorCheck): boolean => c.health === 'warn')) { return 'warn'; }
-    return 'ok';
-  }
-
-  /** Ember-olvasható összegzés a nem-ok check-ekből. Pure (unit-tesztelt). */
-  static buildSummary(checks: DyNTS_DoctorCheck[]): string {
-    const notOk: DyNTS_DoctorCheck[] = checks.filter((c: DyNTS_DoctorCheck): boolean => c.health !== 'ok');
-    if (!notOk.length) {
-      return 'all checks ok';
-    }
-    return notOk
-      .map((c: DyNTS_DoctorCheck): string => `${c.name}: ${c.health}${c.fixHint ? ` — ${c.fixHint}` : ''}`)
-      .join(' | ');
-  }
-}

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

@@ -1,85 +0,0 @@
-
-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));
-  });
-});