npm - @futdevpro/nts-dynamo - Versions diffs - 1.15.8 → 1.15.9 - Mend

@futdevpro/nts-dynamo 1.15.8 → 1.15.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (83) hide show

package/src/_collections/default-not-found-page.const.ts ADDED Viewed

@@ -0,0 +1,22 @@
+/**
+ * Alapértelmezett "Page not found" (404) HTML, amit a static client default fallbackjaként
+ * szolgálunk ki, ha nincs fallbackPath (nem-SPA mód) és a kérés nem egy létező static fájlra mutat.
+ */
+export const DyNTS_defaultNotFoundPageHtml: string =
+  '<!DOCTYPE html>\n' +
+  '<html lang="en">\n' +
+  '<head>\n' +
+  '  <meta charset="utf-8">\n' +
+  '  <meta name="viewport" content="width=device-width, initial-scale=1">\n' +
+  '  <title>Page not found</title>\n' +
+  '  <style>\n' +
+  '    body { font-family: system-ui, sans-serif; margin: 2rem; text-align: center; }\n' +
+  '    h1 { font-size: 1.5rem; color: #333; }\n' +
+  '    p { color: #666; }\n' +
+  '  </style>\n' +
+  '</head>\n' +
+  '<body>\n' +
+  '  <h1>Page not found</h1>\n' +
+  '  <p>The requested resource could not be found.</p>\n' +
+  '</body>\n' +
+  '</html>\n';

package/src/_collections/default-socket-path.const.spec.ts ADDED Viewed

@@ -0,0 +1,12 @@
+import { DyNTS_defaultSocketPath } from './default-socket-path.const';
+describe('| DyNTS_defaultSocketPath', () => {
+  it('| should export default socket path as \'/socket\'', () => {
+    expect(DyNTS_defaultSocketPath).toBe('/socket');
+  });
+  it('| should be a non-empty string', () => {
+    expect(typeof DyNTS_defaultSocketPath).toBe('string');
+    expect(DyNTS_defaultSocketPath.length).toBeGreaterThan(0);
+  });
+});

package/src/_collections/default-socket-path.const.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ /** Default Socket.IO path, ha a portSettings.socketPath nincs megadva. */
2	+ export const DyNTS_defaultSocketPath: string = '/socket';

package/src/_models/control-models/http-settings.control-model.spec.ts CHANGED Viewed

@@ -8,6 +8,7 @@ describe('| DyNTS_Http_Settings', () => {
     expect(settings.httpPort).toBeUndefined();
     expect(settings.httpsPort).toBeUndefined();
+    expect(settings.socketPath).toBeUndefined();
     expect(settings.httpUrlencoded).toEqual({
       limit: '50mb',
       extended: true,
@@ -63,4 +64,14 @@ describe('| DyNTS_Http_Settings', () => {
       limit: '100mb',
     } as BodyParser.OptionsJson);
   });
+  it('| should have socketPath undefined when not provided', () => {
+    const settings = new DyNTS_Http_Settings();
+    expect(settings.socketPath).toBeUndefined();
+  });
+  it('| should set socketPath when provided in constructor', () => {
+    const settings = new DyNTS_Http_Settings({ socketPath: '/ws' });
+    expect(settings.socketPath).toBe('/ws');
+  });
 });

package/src/_models/control-models/http-settings.control-model.ts CHANGED Viewed

@@ -1,8 +1,16 @@
 import * as BodyParser from 'body-parser';
+/**
+ * HTTP/HTTPS és Socket.IO port és body parser beállítások.
+ * socketPath: ha nincs megadva, DyNTS_defaultSocketPath marad;
+ * a kliensnek ugyanazt a path-ot kell használnia.
+ */
 export class DyNTS_Http_Settings {
   httpPort?: number;
   httpsPort?: number;
+  /** Socket.IO path (pl. '/ws'); ha üres, default: DyNTS_defaultSocketPath. */
+  socketPath?: string;
   httpUrlencoded?: BodyParser.OptionsUrlencoded = {
     limit: '50mb',

package/src/_models/interfaces/static-client-settings.interface.spec.ts ADDED Viewed

@@ -0,0 +1,29 @@
+import { DyNTS_StaticClient_Settings } from './static-client-settings.interface';
+describe('| DyNTS_StaticClient_Settings', () => {
+  it('| should allow minimal settings with only root', () => {
+    const s: DyNTS_StaticClient_Settings = { root: '/dist' };
+    expect(s.root).toBe('/dist');
+    expect(s.fallbackPath).toBeUndefined();
+  });
+  it('| should allow optional fallbackPath', () => {
+    const s: DyNTS_StaticClient_Settings = {
+      root: '/dist',
+      fallbackPath: 'index.html',
+    };
+    expect(s.fallbackPath).toBe('index.html');
+  });
+  it('| should allow SPA cache options', () => {
+    const s: DyNTS_StaticClient_Settings = {
+      root: '/dist',
+      assetCacheMaxAge: 31536000,
+      assetCacheImmutable: true,
+      fallbackCacheMaxAge: 0,
+    };
+    expect(s.assetCacheMaxAge).toBe(31536000);
+    expect(s.assetCacheImmutable).toBe(true);
+    expect(s.fallbackCacheMaxAge).toBe(0);
+  });
+});

package/src/_models/interfaces/static-client-settings.interface.ts ADDED Viewed

@@ -0,0 +1,28 @@
+/**
+ * Beállítások a client static fájlok kiszolgálásához (pl. SPA) a '/' path alatt.
+ * Ha megadva, a getStaticClientSettings() által visszaadott értéket a base app
+ * a mountStaticClient() során használja (API route-ok után).
+ * A cache mezők SPA (pl. Angular) optimalizáláshoz opcionálisak; ha nincs kitöltve,
+ * viselkedés változatlan (alkalmas nem-SPA kiszolgálásra is).
+ */
+export interface DyNTS_StaticClient_Settings {
+  /** A static fájlok könyvtárának path-ja (abszolút vagy process.cwd()-hez képest). */
+  root: string;
+  /** SPA fallback: ha a kérés nem egy fájlra mutat, ezt a fájlt szolgáljuk ki (pl. 'index.html'). */
+  fallbackPath?: string;
+  /**
+   * Static asset-ek (pl. JS, CSS) Cache-Control max-age másodpercben.
+   * SPA (Angular) hashed fájloknál pl. 1 év (31536000).
+   */
+  assetCacheMaxAge?: number;
+  /**
+   * Ha true és assetCacheMaxAge is megadva, Cache-Control-hoz hozzáadódik az immutable direktíva
+   * (Angular hashed fájlokra ideális).
+   */
+  assetCacheImmutable?: boolean;
+  /**
+   * Fallback (pl. index.html) Cache-Control max-age másodpercben.
+   * SPA esetén ajánlott 0, hogy a böngésző ne cache-elje az index.html-t (deploy után friss).
+   */
+  fallbackCacheMaxAge?: number;
+}

package/src/_modules/mock/app-extended-server.mock.ts CHANGED Viewed

@@ -96,7 +96,7 @@ export class DyNTS_AppExtendedFull_Mock extends DyNTS_AppExtended {
   getPortSettings(): DyNTS_Http_Settings {
     return {
-      httpPort: 54534,
+      httpPort: 0,
     };
   }
@@ -167,7 +167,7 @@ export class DyNTS_AppWbMock_Mock extends DyNTS_AppExtended {
   getPortSettings(): DyNTS_Http_Settings {
     return {
-      httpPort: 54535,
+      httpPort: 0,
     };
   }

package/src/_modules/mock/app-integration-test.mock.ts ADDED Viewed

@@ -0,0 +1,51 @@
+import { DyNTS_App_Params } from '../../_models/control-models/app-params.control-model';
+import { DyNTS_Http_Settings } from '../../_models/control-models/http-settings.control-model';
+import { DyNTS_StaticClient_Settings } from '../../_models/interfaces/static-client-settings.interface';
+import { DyNTS_AppWbMock_Mock } from './app-extended-server.mock';
+/**
+ * Integrációs tesztekhez használt mock app: DB nélkül indul, unified host beállításokkal
+ * (static client root, API base path, socket path). A static root-ot a spec állítja
+ * beforeAll-ban az integrationStaticRoot statikus property-n keresztül.
+ */
+export class DyNTS_AppIntegrationTest_Mock extends DyNTS_AppWbMock_Mock {
+  /** A spec beforeAll-ban beállítja; getStaticClientSettings() ezt használja root-ként. */
+  static integrationStaticRoot: string = '';
+  override getAppParams(): DyNTS_App_Params {
+    return new DyNTS_App_Params({
+      name: 'nts-integration-test',
+      version: '1.0.0',
+      systemShortCodeName: 'NIT',
+    });
+  }
+  override getPortSettings(): DyNTS_Http_Settings {
+    return {
+      httpPort: 0,
+      socketPath: '/socket',
+    };
+  }
+  /** Az OS által kiosztott tényleges port; ready() után elérhető. */
+  get resolvedPort(): number {
+    const addr = this.httpServer?.address?.();
+    return (typeof addr === 'object' && addr) ? addr.port : 0;
+  }
+  override getApiBasePath(): string {
+    return '/api';
+  }
+  override getStaticClientSettings(): DyNTS_StaticClient_Settings | undefined {
+    if (!DyNTS_AppIntegrationTest_Mock.integrationStaticRoot) {
+      return undefined;
+    }
+    return {
+      root: DyNTS_AppIntegrationTest_Mock.integrationStaticRoot,
+      fallbackPath: undefined,
+    };
+  }
+}

package/src/_modules/mock/app-server.mock.ts CHANGED Viewed

@@ -85,7 +85,7 @@ export class DyNTS_AppFull_Mock extends DyNTS_App {
   getPortSettings(): DyNTS_Http_Settings {
     return {
-      httpPort: 20101,
+      httpPort: 0,
     };
   }
@@ -172,7 +172,7 @@ export class DyNTS_AppTEST_Mock extends DyNTS_App {
   getPortSettings(): DyNTS_Http_Settings {
     return {
-      httpPort: 10203,
+      httpPort: 0,
     };
   }

package/src/_modules/mock/socket-client.mock.spec.ts CHANGED Viewed

@@ -34,7 +34,7 @@ describe('| SocketClient_Mock', () => {
     expect(params).toEqual(jasmine.any(DyNTS_SocketClientService_Params));
     expect(params.service).toBe('-test-socket-target-');
     expect(params.name).toBe('socket-client-mock');
-    expect(params.port).toBe(30303);
+    expect(params.port).toBe(0);
     expect(params.socketOptions.reconnection).toBeTrue();
   });
 });

package/src/_modules/mock/socket-client.mock.ts CHANGED Viewed

@@ -34,7 +34,7 @@ export class SocketClient_Mock extends DyNTS_SocketClient_ServiceBase {
     return new DyNTS_SocketClientService_Params({
       service: '-test-socket-target-',
       name: 'socket-client-mock',
-      port: 30303,
+      port: 0,
       socketOptions: {
         reconnection: true,
       },

package/src/_modules/mock/socket-server.mock.spec.ts CHANGED Viewed

@@ -20,7 +20,7 @@ describe('| DyNTS_SocketServer_Mock', () => {
     expect(params).toBeInstanceOf(DyNTS_SocketServerService_Params);
     expect(params.name).toBe('test');
-    expect(params.port).toBe(19393); // Updated from 9393 to 19393
+    expect(params.port).toBe(0);
   });
   it('| should return an empty array for incoming events', () => {

package/src/_modules/mock/socket-server.mock.ts CHANGED Viewed

@@ -1,6 +1,5 @@
 import { DyFM_SocketEvent } from '@futdevpro/fsm-dynamo/socket';
 import { Socket } from 'socket.io';
-import * as net from 'net';
 import {
   DyNTS_SocketPresence
@@ -10,28 +9,21 @@ import {
 } from '../socket/_models/socket-server-service-params.control-model';
 import { DyNTS_SocketServerService } from '../socket/_services/socket-server.service';
-/**
- * Utility function to find an available port starting from a base port
- */
-const findAvailablePort = (basePort: number): number => {
-  return basePort; // For now, return the base port, but this could be enhanced
-};
 /**
  * Mock Socket Server Service for testing purposes
- * Uses a non-privileged port to avoid EACCES errors on Windows
+ * Uses port 0 so the OS assigns a random available port
  */
-export class DyNTS_SocketServer_Mock extends
+export class DyNTS_SocketServer_Mock extends
   DyNTS_SocketServerService<DyNTS_SocketPresence> {
   static getInstance(): DyNTS_SocketServer_Mock {
     return DyNTS_SocketServer_Mock.getSingletonInstance();
   }
   getServiceParams(): DyNTS_SocketServerService_Params<any> {
     return new DyNTS_SocketServerService_Params({
       name: 'test',
-      port: findAvailablePort(19393), // Changed from 9393 to 19393 (non-privileged port)
+      port: 0,
     });
   }

package/src/_modules/socket/_services/socket-server.service.ts CHANGED Viewed

@@ -508,8 +508,12 @@ export abstract class DyNTS_SocketServerService<
           await this.closeSocket(socket, `${this.params.name} on connection error`, error);
         }
       });
-      if (options?.attachedToExistingServer) {
+      const isAttach: boolean =
+        options?.attachedToExistingServer === true ||
+        (this.params.port === undefined && options?.effectivePort !== undefined);
+      if (isAttach) {
         DyFM_Log.success(
           `\nsocket server setup finished: "${this.params.name}"` +
           (effectivePort !== undefined ? ` (attached to server on port: ${effectivePort})` : ' (attached to existing server)')

package/src/_modules/socket/app-extended.integration.spec.ts ADDED Viewed

@@ -0,0 +1,85 @@
+import * as Fs from 'fs';
+import * as Os from 'os';
+import * as Path from 'path';
+import Axios from 'axios';
+import { DyNTS_defaultNotFoundPageHtml } from '../../_collections/default-not-found-page.const';
+import { DyNTS_AppIntegrationTest_Mock } from '../mock/app-integration-test.mock';
+let INTEGRATION_BASE_URL: string = '';
+const INTEGRATION_READY_TIMEOUT_MS: number = 10000;
+describe('| DyNTS_AppExtended (integration)', (): void => {
+  beforeAll((): void => {
+    jasmine.DEFAULT_TIMEOUT_INTERVAL = INTEGRATION_READY_TIMEOUT_MS + 5000;
+  });
+  let app: DyNTS_AppIntegrationTest_Mock;
+  let tempDir: string = '';
+  beforeAll(async (): Promise<void> => {
+    tempDir = Fs.mkdtempSync(Path.join(Os.tmpdir(), 'dynts-int-'));
+    const indexContent: string = '<!DOCTYPE html><html><body>Integration test index</body></html>';
+    Fs.writeFileSync(Path.join(tempDir, 'index.html'), indexContent, { encoding: 'utf-8' });
+    DyNTS_AppIntegrationTest_Mock.integrationStaticRoot = tempDir;
+    app = new DyNTS_AppIntegrationTest_Mock();
+    await app.ready(INTEGRATION_READY_TIMEOUT_MS);
+    INTEGRATION_BASE_URL = `http://localhost:${app.resolvedPort}`;
+  });
+  afterAll(async (): Promise<void> => {
+    try {
+      if (app?.started) {
+        await app.stop();
+      }
+    } catch {
+      // stop() hiba (pl. socket server már leállt) ne szakítsa meg a suite-ot
+    }
+    if (tempDir && Fs.existsSync(tempDir)) {
+      Fs.rmSync(tempDir, { recursive: true });
+    }
+  });
+  it('| app elindul és started true', (): void => {
+    expect(app.started).toBe(true);
+  });
+  it('| GET nem létező path -> 404 és default "Page not found" HTML', async (): Promise<void> => {
+    const response = await Axios.get(`${INTEGRATION_BASE_URL}/nonexistent-path-xyz`, {
+      validateStatus: (): boolean => true,
+      responseType: 'text',
+    });
+    expect(response.status).toBe(404);
+    expect(response.headers['content-type']).toContain('html');
+    expect(typeof response.data).toBe('string');
+    expect((response.data as string).trim()).toContain('Page not found');
+    expect(response.data).toBe(DyNTS_defaultNotFoundPageHtml);
+  });
+  it('| GET /index.html -> 200 és static tartalom', async (): Promise<void> => {
+    const response = await Axios.get(`${INTEGRATION_BASE_URL}/index.html`, {
+      responseType: 'text',
+    });
+    expect(response.status).toBe(200);
+    expect(response.data).toContain('Integration test index');
+  });
+  it('| GET API base path alatt (mock route) -> 200', async (): Promise<void> => {
+    const response = await Axios.get(`${INTEGRATION_BASE_URL}/api/test-0/test-base`, {
+      responseType: 'text',
+    });
+    expect(response.status).toBe(200);
+    expect(response.data).toBe('test-base');
+  });
+  it('| GET API másik endpoint -> 200', async (): Promise<void> => {
+    const response = await Axios.get(`${INTEGRATION_BASE_URL}/api/test-0/test-simple`, {
+      responseType: 'text',
+    });
+    expect(response.status).toBe(200);
+    expect(response.data).toBe('test-simple');
+  });
+});

package/src/_modules/socket/app-extended.server.ts CHANGED Viewed

@@ -12,6 +12,7 @@ import {
   DyFM_Log,
 } from '@futdevpro/fsm-dynamo';
+import { DyNTS_defaultSocketPath } from '../../_collections/default-socket-path.const';
 import { DyNTS_global_settings } from '../../_collections/global-settings.const';
 import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
 import {
@@ -438,6 +439,7 @@ export abstract class DyNTS_AppExtended extends DyNTS_App {
    * ha a service.port nincs megadva, a getPortSettings() httpPort/httpsPort értékét használjuk.
    * Ha a base app már listenel (httpServer/httpsServer), arra attacholjuk a Socket.IO-t,
    * különben külön httpSocketServer-t hozunk létre és listenelünk.
+   * A Socket.IO path a portSettings.socketPath-ből jön (default: DyNTS_defaultSocketPath); a kliensnek ugyanazt kell használnia.
    */
   private async setupSocketServerServices(): Promise<void> {
     try {
@@ -519,9 +521,10 @@ export abstract class DyNTS_AppExtended extends DyNTS_App {
               this.httpSocketSettingUpCount++;
               this.systemControlsExt.httpSocketServer.started = false;
+              const socketPath: string = this.portSettings.socketPath ?? DyNTS_defaultSocketPath;
               this.allSocketServers.push(
                 await service.setupSocketServer(
-                  new SocketIO.Server(serverForOpen),
+                  new SocketIO.Server(serverForOpen, { path: socketPath }),
                   DyNTS_SocketSecurity.open,
                   (): void => {
                     this.httpSocketSettingUpCount--;
@@ -546,9 +549,10 @@ export abstract class DyNTS_AppExtended extends DyNTS_App {
               this.httpsSocketSettingUpCount++;
               this.systemControlsExt.httpsSocketServer.started = false;
+              const socketPathSecure: string = this.portSettings.socketPath ?? DyNTS_defaultSocketPath;
               this.allSocketServers.push(
                 await service.setupSocketServer(
-                  new SocketIO.Server(this.httpsServer),
+                  new SocketIO.Server(this.httpsServer, { path: socketPathSecure }),
                   DyNTS_SocketSecurity.secure,
                   (): void => {
                     this.httpsSocketSettingUpCount--;

package/src/_services/base/data.service.ts CHANGED Viewed

@@ -1327,7 +1327,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
             ...this._getDefaultErrorSettings(
               'validateByPropertyParams',
               new Error(
-                'Validation failed! (multiple validation errors)' +
+                `Validation failed! (multiple validation errors for ${this.dataParams.dataName})` +
                 validationErrors.map((error: DyFM_Error) => `\n  ${DyFM_Error.getAnyMessage(error)}`).join('')
               )
             ),
@@ -1367,10 +1367,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
   ): void {
     // basic required validations
     if (
-      (
-        propertyParams.required ||
-        propertyParams.index
-      ) && (
+      propertyParams.required && (
         propertyValue === null ||
         propertyValue === undefined
       )
@@ -1380,7 +1377,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
           'validateProperty',
           new Error(
             `validateProperty failed, "${this.getPropertyKey(propertyParams, isSubObjectOf)}" is missing! ` +
-            `(index or required in "${this.dataParams.dataName}" dataParams) ` +
+            `(required in "${this.dataParams.dataName}" dataParams) ` +
             ((data as any)?.name ? `\n  The failed data's name: ${(data as any).name}` : '')
           )
         ),
@@ -1391,7 +1388,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
         validationErrors: {
           [propertyParams.key]: {
             message: `validateProperty failed, "${this.getPropertyKey(propertyParams, isSubObjectOf)}" is missing! ` +
-            `(index or required in "${this.dataParams.dataName}" dataParams) ` +
+            `(required in "${this.dataParams.dataName}" dataParams) ` +
             ((data as any)?.name ? `\n  The failed data's name: ${(data as any).name}` : ''),
             code: `${this.ecBase}DyNTS-DS0-VP1`,
             userMessage: 'The property is required and must be a valid value!',

package/src/_services/base/db.service.ts CHANGED Viewed

@@ -1495,11 +1495,17 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
     }
     if (!properties._deletedBy) {
-      properties._deletedBy = {
+      properties._deletedBy = {
         key: '_deletedBy', type: DyFM_BasicProperty_Type.string,
       };
     }
+    if (!properties._archived) {
+      properties._archived = {
+        key: '_archived', type: DyFM_BasicProperty_Type.date,
+      };
+    }
     return properties;
   }
@@ -1521,10 +1527,12 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
     }
     if (!properties._archived) {
-      properties._archived = {
+      properties._archived = {
         key: '_archived', type: DyFM_BasicProperty_Type.date,
-        required: true,
+        required: true,
       };
+    } else if (properties._archived.required === undefined) {
+      properties._archived.required = true;
     }
     return properties;

package/src/_services/route/routing-module.service.spec.ts CHANGED Viewed

@@ -1,6 +1,7 @@
 import { DyFM_Error, DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
 import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
 import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
 import {
@@ -80,4 +81,18 @@ describe('| DyNTS_RoutingModule', () => {
     routingModule.endpoints = [ mockEndpoint, mockEndpoint ];
     expect(() => routingModule['mountRoutes']()).toThrowError(/ENDPOINT DUPLICATION/);
   });
+  it('| should use DyNTS_global_settings.baseUrl as route prefix', () => {
+    const originalBaseUrl: string = DyNTS_global_settings.baseUrl;
+    try {
+      DyNTS_global_settings.baseUrl = '/custom-api';
+      const moduleWithCustomBase: DyNTS_RoutingModule = new DyNTS_RoutingModule({
+        route: '/foo',
+        controllers: [ mockController ],
+      });
+      expect(moduleWithCustomBase.route).toBe('/custom-api/foo');
+    } finally {
+      DyNTS_global_settings.baseUrl = originalBaseUrl;
+    }
+  });
 });