@futdevpro/nts-dynamo 1.15.7 → 1.15.9

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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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/_models/socket-server-service-params.control-model.spec.ts

@@ -30,4 +30,17 @@ describe('| DyNTS_SocketServerService_Params', () => {
     expect(instance.port).toBe(8080);
     expect(instance.security).toBe(DyNTS_global_settings.defaultSocketSecurity);
   });
+
+  it('| should allow port to be omitted (optional, default used by app-extended)', () => {
+    const params = {
+      name: 'TestSocketNoPort',
+      security: DyNTS_SocketSecurity.open,
+    };
+
+    const instance = new DyNTS_SocketServerService_Params(params);
+
+    expect(instance.name).toBe('TestSocketNoPort');
+    expect(instance.port).toBeUndefined();
+    expect(instance.security).toBe(DyNTS_SocketSecurity.open);
+  });
 });

package/src/_modules/socket/_models/socket-server-service-params.control-model.ts

@@ -3,11 +3,13 @@ import { DyNTS_global_settings } from '../../../_collections/global-settings.con
 import { DyNTS_SocketSecurity } from '../_enums/socket-security.enum';
 
 /**
- * socket handling and clarification is under development
+ * Socket service paraméterek.
+ * A port opcionális: ha nincs megadva, az app-extended a getPortSettings() httpPort/httpsPort értékét használja (ugyanaz a port, mint a HTTP/HTTPS).
  */
 export class DyNTS_SocketServerService_Params<T = any> {
   name: string;
-  port: number;
+  /** Opcionális: ha nincs megadva, az extended app a HTTP/HTTPS portot használja (same port). */
+  port?: number;
   security?: DyNTS_SocketSecurity;
 
   constructor(

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

@@ -21,6 +21,14 @@ import {
   DyNTS_SocketServerService_Params
 } from '../_models/socket-server-service-params.control-model';
 
+/** Opciók a setupSocketServer híváshoz: attacholt HTTP szerver esetén ne hívjuk a listen()-t. */
+export interface DyNTS_SocketServerSetupOptions {
+  /** Ha true, a Socket.IO egy már listenelő HTTP/HTTPS szerverre van attacholva – ne hívjuk a listen()-t. */
+  attachedToExistingServer?: boolean;
+  /** A tényleges port (pl. defaultolt httpPort/httpsPort) – logokban használjuk. */
+  effectivePort?: number;
+}
+
 /**
  * You need to define the following functions:
  * ```ts
@@ -42,7 +50,7 @@ export abstract class DyNTS_SocketServerService<
 
   protected params: DyNTS_SocketServerService_Params;
   get name(): string { return this.params.name; }
-  get port(): number { return this.params.port; }
+  get port(): number | undefined { return this.params.port; }
   get security(): DyNTS_SocketSecurity { return this.params.security; }
   get activeSubscriptionsCount(): number { return this.presences.length; }
 
@@ -270,11 +278,14 @@ export abstract class DyNTS_SocketServerService<
   async setupSocketServer(
     newSocketServer: SocketIO.Server, 
     security: DyNTS_SocketSecurity.open | DyNTS_SocketSecurity.secure, 
-    successCallback: () => void
+    successCallback: () => void,
+    options?: DyNTS_SocketServerSetupOptions
   ): Promise<SocketIO.Server> {
     try {
       if (this.highDetailedLogs) console.log('\nfn:. setupSocketServer');
 
+      const effectivePort: number | undefined = options?.effectivePort ?? this.params.port;
+
       newSocketServer.on(DyFM_SocketEvent_Key.incomingNewConnection, async (socket: SocketIO.Socket) => {
         try {
           let issuer: string;
@@ -497,16 +508,35 @@ export abstract class DyNTS_SocketServerService<
           await this.closeSocket(socket, `${this.params.name} on connection error`, error);
         }
       });
-        
+
+      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)')
+        );
+        successCallback();
+      } else {
       try {
-        newSocketServer.listen(this.params.port);
+        const portToListen: number | undefined = this.params.port ?? options?.effectivePort;
+        if (portToListen === undefined) {
+          throw new Error(
+            `PORT NOT SET: "${this.params.name}". ` +
+            `Either set port in getServiceParams() or pass effectivePort in setupSocketServer options.`
+          );
+        }
+        newSocketServer.listen(portToListen);
         
         DyFM_Log.success(
           `\nsocket server setup finished: "${this.params.name}"` + 
-          `\nsocket server listening on port: "${this.params.port}"`
+          `\nsocket server listening on port: "${portToListen}"`
         );
       } catch (listenError) {
-        const errorMessage = `Failed to bind socket server "${this.params.name}" to port ${this.params.port}. ` +
+        const portForMsg: number | undefined = this.params.port ?? options?.effectivePort;
+        const errorMessage = `Failed to bind socket server "${this.params.name}" to port ${portForMsg}. ` +
           `This could be due to port already in use or insufficient permissions. ` +
           `Please ensure the port is available and try again.`;
         
@@ -515,6 +545,7 @@ export abstract class DyNTS_SocketServerService<
       }
 
       successCallback();
+      }
       
       if (security === DyNTS_SocketSecurity.open) {
         this.openSocketServer = newSocketServer;

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

@@ -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

@@ -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 {
@@ -112,7 +113,7 @@ import { DyNTS_SocketServerService } from './_services/socket-server.service';
  * 
  *     ...
  *   
- *     // Setting up Sockets
+ *     // Setting up Sockets (port opcionális – ha nincs megadva, a HTTP/HTTPS portot használjuk, same port)
  *     this.socketServices = [
  *       NotificationService.getInstance(),
  *       ChatService.getInstance(),
@@ -130,9 +131,12 @@ export abstract class DyNTS_AppExtended extends DyNTS_App {
 
   private socketSecurity: DyNTS_RouteSecurity;
 
-  private httpSocketServer: Http.Server;
+  /** Csak akkor van értékadva, ha nincs base httpServer (pl. nincs open route) és open socket van. */
+  private httpSocketServer: Http.Server | undefined;
   
   /**
+   * Socket szolgáltatások. A port opcionális: ha nincs megadva, az extended app
+   * a getPortSettings() httpPort/httpsPort értékét használja (WebSocket és HTTP ugyanazon a porton).
    * @example
    * // Setting up Sockets
    * this.socketServices = [
@@ -431,19 +435,25 @@ export abstract class DyNTS_AppExtended extends DyNTS_App {
   }
 
   /**
-   * 
+   * Socket szerverek felállítása. By default a socket a HTTP/HTTPS porton fut (same port);
+   * 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 {
       if (this.fnLogs) console.log('\nfn:. setupSocketServerServices');
-      /* let httpServer: Http.Server; */
+
+      const useBaseHttpServer: boolean = !!this.httpServer;
+      const useBaseHttpsServer: boolean = !!this.httpsServer;
 
       if (this.socketSecurity !== DyNTS_RouteSecurity.secure) {
         if (!this.openExpress) {
           await this.initOpenExpress();
         }
 
-        if (!this.httpSocketServer) {
+        if (!useBaseHttpServer && !this.httpSocketServer) {
           this.httpSocketServer = Http.createServer(this.openExpress);
         }
       }
@@ -464,8 +474,10 @@ export abstract class DyNTS_AppExtended extends DyNTS_App {
               
             errorMsg += '\n\nThe socket services setted to use secure server:';
             this.socketServices.forEach((service: DyNTS_SocketServerService<any>): void => {
-              if (service.security != DyNTS_SocketSecurity.open) {
-                errorMsg += `\n  ${service?.name} (port: ${service.port})`;
+              if (service.security !== DyNTS_SocketSecurity.open) {
+                const effPort: number | undefined = service.port ??
+                  this.portSettings.httpsPort;
+                errorMsg += `\n  ${service?.name} (port: ${effPort})`;
               }
             });
     
@@ -486,49 +498,33 @@ export abstract class DyNTS_AppExtended extends DyNTS_App {
         this.socketServices, 
         async (service: DyNTS_SocketServerService<any>): Promise<void> => {
           try {
-            this.systemControlsExt.httpSocketServer.init = true;
-            
-            if (!service.port) {
-              throw new Error(
-                `PORT NOT SET: "${service.name}"`
-              );
-            }
-
-            const existingPorts: DyNTS_SocketServerService<any>[] = this.socketServices.filter(
-              (mod: DyNTS_SocketServerService<any>): boolean => mod.port === service.port
-            );
+            const effectivePort: number | undefined = service.security === DyNTS_SocketSecurity.open
+              ? (service.port ?? this.portSettings.httpPort)
+              : (service.port ?? this.portSettings.httpsPort);
 
-            if (
-              1 < existingPorts.length || 
-              this.portSettings.httpPort === service.port || 
-              this.portSettings.httpsPort === service.port
-            ) {
-              const error = new Error(
-                `PORT DUPLICATION: "${service.port}"` +
-                `\n  same ports at: ${existingPorts.map(
-                  (sss: DyNTS_SocketServerService<any>): string => sss.name
-                ).join(', ')}`
+            if (effectivePort === undefined) {
+              throw new Error(
+                `PORT NOT SET: "${service.name}". ` +
+                `Set port in getServiceParams() or ensure getPortSettings() returns httpPort/httpsPort.`
               );
-              const errorStack: string[] = error.stack?.split('\n');
-
-              errorStack.splice(1, 4);
-              error.stack = errorStack.join('\n');
-
-              DyFM_Log.error(`\n${error.message}`);
-
-              throw error;
             }
 
             if (service.security === DyNTS_SocketSecurity.open) {
+              this.systemControlsExt.httpSocketServer.init = true;
+              const serverForOpen: Http.Server = useBaseHttpServer
+                ? this.httpServer
+                : this.httpSocketServer!;
               if (this.logSetup) console.log(
-                `\nsocket setup (open): ${service?.name}:${service.port}`
+                `\nsocket setup (open): ${service?.name}:${effectivePort}` +
+                (useBaseHttpServer ? ' (shared with HTTP)' : '')
               );
               this.httpSocketSettingUpCount++;
               this.systemControlsExt.httpSocketServer.started = false;
 
+              const socketPath: string = this.portSettings.socketPath ?? DyNTS_defaultSocketPath;
               this.allSocketServers.push(
                 await service.setupSocketServer(
-                  new SocketIO.Server(this.httpSocketServer), 
+                  new SocketIO.Server(serverForOpen, { path: socketPath }), 
                   DyNTS_SocketSecurity.open, 
                   (): void => { 
                     this.httpSocketSettingUpCount--;
@@ -536,20 +532,27 @@ export abstract class DyNTS_AppExtended extends DyNTS_App {
                     if (this.httpSocketSettingUpCount === 0) {
                       this.systemControlsExt.httpSocketServer.started = true;
                     }
+                  },
+                  {
+                    attachedToExistingServer: useBaseHttpServer,
+                    effectivePort: effectivePort,
                   }
                 )
               );
 
             } else if (service.security === DyNTS_SocketSecurity.secure) {
+              this.systemControlsExt.httpsSocketServer.init = true;
               if (this.logSetup) console.log(
-                `\nsocket setup (secure): ${service?.name}:${service.port}`
+                `\nsocket setup (secure): ${service?.name}:${effectivePort}` +
+                (useBaseHttpsServer ? ' (shared with HTTPS)' : '')
               );
               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--;
@@ -557,6 +560,10 @@ export abstract class DyNTS_AppExtended extends DyNTS_App {
                     if (this.httpsSocketSettingUpCount === 0) {
                       this.systemControlsExt.httpsSocketServer.started = true;
                     }
+                  },
+                  {
+                    attachedToExistingServer: useBaseHttpsServer,
+                    effectivePort: effectivePort,
                   }
                 )
               );

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

@@ -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

@@ -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

@@ -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;
+    }
+  });
 });