@futdevpro/nts-dynamo 1.15.157 → 1.15.163

package/src/_models/control-models/endpoint-params.control-model.ts

@@ -1,575 +0,0 @@
-import { Request, Response } from 'express';
-
-import {
-  DyFM_AnyError, DyFM_Array, DyFM_Endpoint_SettingsBase, DyFM_Error, DyFM_getConstructionStackLocation,
-  DyFM_HttpCallType, DyFM_Log, DyFM_Object
-} from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
-import { DyNTS_ClientSafeError_Util } from '../../_collections/client-safe-error.util';
-import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
-import {
-  DyNTS_SafeDiagnostic_ControlService
-} from '../../_modules/server/safe-diagnostic/safe-diagnostic.control-service';
-import {
-  DyNTS_SafeDiagnosticStage_Type
-} from '../../_modules/server/safe-diagnostic/safe-diagnostic-stage.type-enum';
-import { DyNTS_SafeDiagnostic_Interface } from '../../_modules/server/safe-diagnostic/safe-diagnostic.interface';
-import { DyNTS_GlobalService } from '../../_services/core/global.service';
-import { DyNTS_RequestHunter } from '../../_services/core/request-hunter.service';
-
-/**
- * High level endpoint for API
- * used for specific events such as saving or getting data,
- * triggering events, logging in or out, and much more
- * 
- * (You'll need to add them to a {@link DyNTS_Controller} through the {@link DyNTS_Controller.addEndpoint} method)
- * 
- * @example
- * ```typescript
- * // Example from note-book controller implementation
- * new DyNTS_Endpoint_Params({
- *   name: 'getMyNoteBooks',
- *   type: DyFM_HttpCallType.get,
- *   endpoint: '/:userId/get-my',
- *   preProcesses: [ authService.authenticate_tokenSelf ],
- *   tasks: [
- *     async (req: Request, res: Response, issuer: string): Promise<void> => {
- *       const notes_DS = new NoteBook_DataService({
- *         issuer: issuer,
- *       });
- * 
- *       const notes = await notes_DS.getMyNoteBooks(req.params.userId);
- *       res.send(notes);
- *     },
- *   ],
- * })
- * ```
- */
-export class DyNTS_Endpoint_Params<
-  T_Result = unknown,
-  I_Inputs extends Array<any> = [], 
-  T_Body = undefined
-> extends DyFM_Endpoint_SettingsBase<T_Result, I_Inputs, T_Body> {
-  /* name: string; */
-  security: DyNTS_RouteSecurity;
-
-  /* type: DyFM_HttpCallType;
-  endpoint: string; */
-
-  /* TODO: ENCRYPTION !!EZTET
-  useEncryptionKey?: string; */
-
-  private readonly pathParams: string[];
-
-  private readonly preProcesses: ((req: Request, res: Response) => Promise<void>)[] = [];
-  private readonly tasks: ((req: Request, res: Response, issuer?: string) => Promise<void>)[];
-
-  private readonly logRequest: boolean;
-  private readonly logRequestsParams: boolean;
-  private readonly logRequestsContent: boolean;
-  private readonly logResponseContent: boolean;
-  readonly stackLocation: string;
-  private readonly autoResolveCirculation: boolean;
-
-  constructor(
-    set: {
-      /**
-       * naming the endpoint will help to follow events on service
-       */
-      name: string,
-      /**
-       * security settings for API, different security paths will need different handlers 
-       * 
-       * open; http, secure; https or both
-       */
-      security?: DyNTS_RouteSecurity,
-
-      /**
-       * define basic Http Call Type such as; get, post, put, patch, delete
-       */
-      type: DyFM_HttpCallType,
-      /**
-       * set endpoint here, without baseUrl and route module path
-       * 
-       * NOTE: the endpoint will already include the routing module's endpoint.
-       * like: '/get-user/:userId' will be like: '/api/user/get-user/:userId'
-       */
-      endpoint: string,
-      
-      /**
-       * preProcesses are the functions you need to run before the actual function,
-       * such as authentications
-       */
-      preProcesses?: ((req: Request, res: Response) => Promise<void>)[],
-      /**
-       * the actual tasks to run, 
-       * the last one should contain the res.send(); execution to send response on API requests
-       */
-      tasks: ((req: Request, res: Response, issuer: string) => Promise<void>)[],
-
-      /**
-       * log settings for request and response
-       */
-      logRequest?: boolean,
-      /**
-       * log settings for request params
-       */
-      logRequestsParams?: boolean,
-      /**
-       * log settings for request content
-       */
-      logRequestsContent?: boolean,
-      /**
-       * log settings for response content
-       */
-      logResponseContent?: boolean,
-      /**
-       * auto resolve circulation errors
-       */
-      autoResolveCirculation?: boolean,
-    }
-  ) {
-    try {
-      super(set);
-
-      this.name = set.name ?? set.endpoint;
-      this.security = set.security ?? DyNTS_global_settings.defaultRouteSecurity;
-
-      this.type = set.type;
-      this.endpoint = set.endpoint;
-
-      this.logRequest = set.logRequest ?? DyNTS_global_settings.log_settings.request;
-      this.logRequestsParams = set.logRequestsParams ?? 
-        DyNTS_global_settings.log_settings.requestsParams;
-      this.logRequestsContent = set.logRequestsContent ?? 
-        DyNTS_global_settings.log_settings.requestsContent;
-      this.logResponseContent = set.logResponseContent ?? 
-        DyNTS_global_settings.log_settings.responseContent;
-      this.autoResolveCirculation = set.autoResolveCirculation ?? 
-        DyNTS_global_settings.autoResolveEndpointCirculationErrors;
-
-      if (!this.endpoint) {
-        throw new DyFM_Error({
-          status: 406, 
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EP0-C00`,
-          addECToUserMsg: true,
-          message: 'trying to create DyNTS_Endpoint_Params without endpoint value',
-          userMessage: 
-            'We encountered an unhandled Server Error, ' +
-            'please contact the responsible development team.',
-          additionalContent: set,
-        });
-      }
-
-      let pathParts: string[] = this.endpoint.split('/');
-
-      pathParts = pathParts.filter((part: string): boolean => part.startsWith(':'));
-      pathParts = pathParts.map((part: string): string => part.replace(':', ''));
-      this.pathParams = pathParts;
-
-      this.preProcesses = set.preProcesses ?? [];
-      this.tasks = set.tasks ?? [];
-      
-      this.stackLocation = DyFM_getConstructionStackLocation();
-    } catch (error) {
-      DyNTS_SafeDiagnostic_ControlService.report({
-        code: 'DYNTS|ENDPOINT|CONSTRUCTION_FAILURE',
-        stage: DyNTS_SafeDiagnosticStage_Type.endpoint,
-        error: error,
-      });
-
-      throw error;
-    }
-  }
-
-  /**
-   * 
-   * @returns 
-   */
-  private async preLog(req: Request, res: Response, issuer: string): Promise<void> {
-    try {
-      if (this.logRequest) {
-        let msg: string = `\n===>>>      incoming '${this.name}' request... (issuer: ${issuer})`;
-
-        if (this.logRequestsParams) {
-          const params = this.getPathParamsLogContent(req);
-
-          msg += `\npathParams: ${params}`;
-        }
-
-        if (
-          this.logRequestsContent && 
-          req.body && 
-          0 < Object.keys(req.body).length
-        ) {
-          DyFM_Log.info(msg + `\nbody:`, req.body);
-        } else {
-          DyFM_Log.info(msg);
-        }
-      }
-    } catch (error) {
-      this.error(req, res, error, issuer);
-    }
-  }
-
-  /**
-   * 
-   * @returns 
-   */
-  getFullExecution(): (req: Request, res: Response) => Promise<void> {
-    let issuer: string;
-
-    return async (req: Request, res: Response): Promise<void> => {
-      // ISSUE-HUNTER (2026-08-05) — keres-szintu attribucio. Ez a KOZPONTI vegrehajtasi pont,
-      // minden endpoint ezen megy at, ezert itt (es CSAK itt) merunk. Koltseg: egy Map-beszuras
-      // + Date.now(). A `finally` garantalja, hogy hiba/early-return eseten se szivarogjon be-
-      // jegyzes. Reszletes indoklas: `DyNTS_RequestHunter`.
-      const hunterId: number = DyNTS_RequestHunter.getInstance().begin(this.name);
-      try {
-        try {
-          issuer = DyNTS_GlobalService?.getAuthService()?.getIssuerFromRequest(req);
-        } catch (error) {
-          DyNTS_SafeDiagnostic_ControlService.report({
-            code: 'DYNTS|ENDPOINT|ISSUER_RESOLUTION_FAILURE',
-            stage: DyNTS_SafeDiagnosticStage_Type.endpoint,
-            error: error,
-          });
-          issuer = 'unknown-issuer';
-        }
-        
-        if (this.logRequest) {
-          await this.preLog(req, res, issuer);
-        }
-
-        if (DyNTS_global_settings.log_settings.requestStackLocation) {
-          DyFM_Log.info(`              endpoint location: "${this.stackLocation}"`);
-        }
-
-        if (!this.preProcesses) {
-          throw new DyFM_Error({
-            status: 500, 
-            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EP1-C00`,
-            addECToUserMsg: true,
-            message: 
-              'trying to execute DyNTS_Endpoint_Params without preProcesses value, ' +
-              'make sure you are using DyNTS_Endpoint_Params constructor correctly',
-            userMessage: 
-              'We encountered an unhandled Server Error, ' +
-              'please contact the responsible development team.',
-          });
-        }
-
-        await DyFM_Array.asyncForEach(this.preProcesses,
-          async (preProcess: (req: Request, res: Response) => Promise<void>): Promise<void> => {
-            await preProcess(req, res);
-          }
-        );
-
-        // FR-263 defense-in-depth (security): ha egy preProcess (pl. egy auth-guard) MÁR választ küldött
-        // (`res.headersSent` — pl. egy 401-et vagy redirect-et), NE futtassuk a task-okat. Enélkül egy
-        // response-t küldő guard után is lefutna az endpoint-logika, és a task 200-as válasza felül-
-        // írhatná/megelőzhetné a guard elutasítását → info-disclosure (l. FR-263 auth error-endpoint leak).
-        // Standard Express-minta; a normál (nem-válaszoló preProcess-ű) endpointokra nincs hatással.
-        if (res.headersSent) {
-          return;
-        }
-
-        // BFR-OVERSEER-010: a logResponseContent IMPLEMENTÁLVA (a korábbi "not implemented yet"
-        // warn-stub minden requestre spam-elt). A res.send-et wrap-eljük a küldött body
-        // elkapásához; a task-ok után csonkolt preview-t logolunk (log-flood ellen).
-        let capturedResponseBody: unknown;
-        if (this.logRequest && this.logResponseContent) {
-          const originalSend: Response['send'] = res.send.bind(res);
-          res.send = (body?: unknown): Response => {
-            capturedResponseBody = body;
-            return originalSend(body);
-          };
-        }
-
-        await DyFM_Array.asyncForEach(this.tasks,
-          async (
-            task: (req: Request, res: Response, issuer?: string) => Promise<void>
-          ): Promise<void> => {
-            await task(req, res, issuer);
-          }
-        );
-
-        if (this.logRequest) {
-          DyFM_Log.success(`  <<<=====   '${this.name}' result sent.`);
-          if (this.logResponseContent) {
-            DyFM_Log.info(`              response: ${DyNTS_Endpoint_Params.previewBody(capturedResponseBody)}`);
-          }
-        }
-      } catch (error) {
-        await this.error(req, res, error, issuer);
-      } finally {
-        DyNTS_RequestHunter.getInstance().end(hunterId);
-      }
-    };
-  }
-
-  /**
-   * BFR-OVERSEER-010: csonkolt, safe response-preview a logResponseContent-hez —
-   * nem-parseolható/circular body-ra nem dob, hosszú body-t levág (log-flood ellen).
-   */
-  private static previewBody(body: unknown): string {
-    const maxLength: number = 2000;
-    let text: string;
-    if (body === undefined) {
-      return '-no body captured-';
-    }
-    if (typeof body === 'string') {
-      text = body;
-    } else {
-      try {
-        text = JSON.stringify(body);
-      } catch {
-        text = String(body);
-      }
-    }
-    return text.length > maxLength ? `${text.slice(0, maxLength)}…(truncated ${text.length} chars)` : text;
-  }
-
-  /**
-   * 
-   * @param res 
-   * @param error 
-   */
-  private async error(
-    req: Request, 
-    res: Response, 
-    error: DyFM_AnyError, 
-    issuer: string,
-    autoSecondTry?: boolean
-  ): Promise<void> {
-    try {
-      const status: number = DyNTS_Endpoint_Params.resolveErrorStatus(error);
-      const diagnostic: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.report({
-        code: 'DYNTS|ENDPOINT|FAILURE',
-        stage: DyNTS_SafeDiagnosticStage_Type.endpoint,
-        error: error,
-        status: status,
-      });
-
-      try {
-        await DyNTS_GlobalService.globalErrorHandler?.(
-          error,
-          req,
-          res,
-          issuer
-        );
-      } catch (handlerError) {
-        DyNTS_SafeDiagnostic_ControlService.report({
-          code: 'DYNTS|ENDPOINT|GLOBAL_HANDLER_FAILURE',
-          stage: DyNTS_SafeDiagnosticStage_Type.endpoint,
-          error: handlerError,
-        });
-      }
-      
-      // FR-067 (2026-06-06): non-DyFM_Error wrap.
-      // Korabban a plain Error / axios HTTP error nyersen ment kifele
-      // -> kliens "[object Object]"-et latott, nem volt _errorCode, nem volt
-      // userMessage, a kliens-oldali DyFM_Error pipeline ures error-t kapott.
-      // Most MINDEN non-DyFM_Error errort egy DyFM_Error-ba csomagolunk
-      // az endpoint-nev-vel es a system short-code-jal egy felismerheto
-      // `_errorCode`-szal: `<SYSTEM>|DyNTS-EPP-<endpointName>`.
-      // Plusz a downstream HTTP-status-t (axios `status` / Express `statusCode`)
-      // betesszuk a DyFM_Error `___status` mezojebe, igy a kovetkezo blokk
-      // mar konzekvensen olvasni tudja.
-      if (!(error instanceof DyFM_Error)) {
-        error = new DyFM_Error({
-          message: 'Unhandled endpoint failure.',
-          errorCode: this.getClientErrorCode(),
-          userMessage: 'An internal error occurred.\nPlease contact the responsible development team.',
-          additionalContent: { diagnostic: diagnostic },
-          status: status,
-        });
-      }
-
-      if (error instanceof DyFM_Error) {
-        if (DyNTS_global_settings.compactErrorResponse) {
-          error = (error as DyFM_Error).getErrorsFlat();
-          delete (error as DyFM_Error).errors;
-          /* delete (error as DyFM_Error).error; */
-          delete (error as DyFM_Error).stack;
-        }
-      }
-
-      if (
-        (error as DyFM_Error)?.flag?.includes('DYNAMO') && 
-        (error as DyFM_Error).confidentialContent
-      ) {
-        delete (error as DyFM_Error).confidentialContent;
-      }
-
-      try {
-        JSON.stringify(error);
-      } catch /* (stringifyError) */ {
-        if (this.autoResolveCirculation) {
-          try {
-            error = DyFM_Object.resolveCirculation(error);
-            JSON.stringify(error);
-          } catch /* (resolveError) */ {
-            DyFM_Log.H_error(
-              'DyNTS_Endpoint_Params: error object is not serializable, and not resolvable!'
-            );
-
-            error = new DyFM_Error({
-              error: new Error('UNRESOLVABLE UNSERIALIZABLE ERROR'),
-            });
-          }
-        } else {
-          DyFM_Log.H_error('DyNTS_Endpoint_Params: error object is not serializable!');
-
-          error = new DyFM_Error({
-            error: new Error('UNSERIALIZABLE ERROR'),
-          });
-        }
-      }
-
-      // FR-066 (2026-06-05): a default-status fallback 501 helyett 500-ra
-      // valtott. A 501 ('Not Implemented') felrevezeto klienseknek (az endpoint
-      // LETEZIK, csak a handler ___status-nelkuli error-t dobott). A 500
-      // ('Internal Server Error') a standard fallback erre. Plusz:
-      // tovabbi konvenciókat is olvasunk a status-resolver-ben — DyFM_Error
-      // `___status`-en kívül a `statusCode` (Express convention) es `status`
-      // (axios / general HTTP) mezőket is. Igy a downstream HTTP-hivasok
-      // (pl. axios-bol jovo error) helyes HTTP-status-szal továbbítódnak.
-      res.status(DyNTS_Endpoint_Params.resolveErrorStatus(error));
-
-      // Kliens-safe strip ENV-FÜGGETLENÜL (BFR-FDPAUTHSERVICE-002): a korábbi prod-only blokk a
-      // test/dev környezetben TELJES DyFM-leaket hagyott (__localStack + ___systemVersion + issuer).
-      // A szabályok (mindig-strip / prod-only additionalContent / kliens-mezők megtartása) SSOT-ja
-      // a DyNTS_ClientSafeError_Util.
-      // BFR-OVERSEER-010: a kiküldött client-safe error megőrzése a logResponseContent-hez.
-      const clientSafeError: unknown = DyNTS_ClientSafeError_Util.toClientSafe(error);
-      res.send(clientSafeError);
-
-      if (this.logRequest) {
-        DyFM_Log.error('[DyNTS endpoint error response sent]', diagnostic);
-      }
-          
-    } catch (errorLvl2) {
-      this.multiLevelError(
-        errorLvl2,
-        { 
-          req: req, 
-          res: res, 
-          error: error, 
-          issuer: issuer, 
-          autoSecondTry: autoSecondTry, 
-        }
-      );
-    }
-  }
-
-  private multiLevelError(
-    errorLvl2: any, 
-    errorInputs: { 
-      req: Request, 
-      res: Response, 
-      error: Error | DyFM_Error, 
-      issuer: string,
-      autoSecondTry: boolean
-    }
-  ): void {
-    DyNTS_SafeDiagnostic_ControlService.report({
-      code: 'DYNTS|ENDPOINT|ERROR_HANDLER_FAILURE',
-      stage: DyNTS_SafeDiagnosticStage_Type.endpoint,
-      error: errorLvl2,
-    });
-
-    try {
-      JSON.stringify(errorInputs.error);
-    } catch /* (errorLvl2Replication) */ {
-      DyFM_Log.error('  ...response object is not serializable!');
-      let resolvedError: any;
-
-      try {
-        resolvedError = DyFM_Object.resolveCirculation(errorInputs.error);
-      } catch (errorLvl3) {
-        DyNTS_SafeDiagnostic_ControlService.report({
-          code: 'DYNTS|ENDPOINT|CIRCULATION_RESOLUTION_FAILURE',
-          stage: DyNTS_SafeDiagnosticStage_Type.endpoint,
-          error: errorLvl3,
-        });
-      }
-      
-      if (resolvedError) {
-        if (this.autoResolveCirculation && !errorInputs.autoSecondTry) {
-          this.error(
-            errorInputs.req, 
-            errorInputs.res, 
-            resolvedError,
-            errorInputs.issuer,
-            true
-          );
-
-          DyFM_Log.warn('  ...automatic circulation error resolution was successful!');
-
-          return;
-        } else {
-          DyFM_Log.error(
-            '  ...response object is resolvable! (use DyFM_Object.resolveCirculation)'
-          );
-        }
-      }
-    }
-
-  }
-
-  /** Resolves conventional HTTP status fields without inspecting raw error content. */
-  private static resolveErrorStatus(error: unknown): number {
-    try {
-      if (error === null || (typeof error !== 'object' && typeof error !== 'function')) {
-        return 500;
-      }
-
-      const statusRaw: unknown = Reflect.get(error, '___status')
-        ?? Reflect.get(error, 'statusCode')
-        ?? Reflect.get(error, 'status');
-      const status: number = typeof statusRaw === 'number' ? statusRaw : Number(statusRaw);
-
-      return Number.isInteger(status) && status >= 100 && status <= 599 ? status : 500;
-    } catch {
-      return 500;
-    }
-  }
-
-  /** Preserves the public error-code shape while excluding arbitrary endpoint-name characters. */
-  private getClientErrorCode(): string {
-    const systemCode: string = DyNTS_Endpoint_Params.sanitizeCodePart(
-      DyNTS_global_settings.systemShortCodeName,
-      'DYNTS'
-    );
-    const endpointCode: string = DyNTS_Endpoint_Params.sanitizeCodePart(this.name, 'UNKNOWN');
-
-    return `${systemCode}|DyNTS-EPP-${endpointCode}`;
-  }
-
-  /** Bounds developer-owned identifiers to the established error-code alphabet. */
-  private static sanitizeCodePart(value: unknown, fallback: string): string {
-    if (typeof value !== 'string') {
-      return fallback;
-    }
-
-    const sanitized: string = value.replace(/[^A-Za-z0-9_-]/g, '_').slice(0, 64);
-
-    return sanitized || fallback;
-  }
-
-  private getPathParamsLogContent(req: Request): string {
-    let params: string = '';
-    
-    this.pathParams.forEach((param: string): void => {
-      params += `\n${param}: ${req.params[param]}`;
-    });
-
-    return params;
-  }
-}
-
-
-
-

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

@@ -1,77 +0,0 @@
-
-import { DyNTS_Http_Settings } from './http-settings.control-model';
-import * as BodyParser from 'body-parser';
-
-describe('| DyNTS_Http_Settings', () => {
-  it('| should create an instance with default settings', () => {
-    const settings = new DyNTS_Http_Settings();
-
-    expect(settings.httpPort).toBeUndefined();
-    expect(settings.httpsPort).toBeUndefined();
-    expect(settings.socketPath).toBeUndefined();
-    expect(settings.httpUrlencoded).toEqual({
-      limit: '50mb',
-      extended: true,
-    } as BodyParser.OptionsUrlencoded);
-    expect(settings.httpJson).toEqual({
-      limit: '50mb',
-    } as BodyParser.OptionsJson);
-    expect(settings.httpsUrlencoded).toEqual({
-      limit: '50mb',
-      extended: true,
-    } as BodyParser.OptionsUrlencoded);
-    expect(settings.httpsJson).toEqual({
-      limit: '50mb',
-    } as BodyParser.OptionsJson);
-  });
-
-  it('| should create an instance with provided settings', () => {
-    const customSettings: DyNTS_Http_Settings = {
-      httpPort: 8080,
-      httpsPort: 8443,
-      httpUrlencoded: {
-        limit: '100mb',
-        extended: false,
-      },
-      httpJson: {
-        limit: '100mb',
-      },
-      httpsUrlencoded: {
-        limit: '100mb',
-        extended: false,
-      },
-      httpsJson: {
-        limit: '100mb',
-      },
-    };
-
-    const settings = new DyNTS_Http_Settings(customSettings);
-
-    expect(settings.httpPort).toBe(8080);
-    expect(settings.httpsPort).toBe(8443);
-    expect(settings.httpUrlencoded).toEqual({
-      limit: '100mb',
-      extended: false,
-    } as BodyParser.OptionsUrlencoded);
-    expect(settings.httpJson).toEqual({
-      limit: '100mb',
-    } as BodyParser.OptionsJson);
-    expect(settings.httpsUrlencoded).toEqual({
-      limit: '100mb',
-      extended: false,
-    } as BodyParser.OptionsUrlencoded);
-    expect(settings.httpsJson).toEqual({
-      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

@@ -1,37 +0,0 @@
-
-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', 
-    extended: true,
-  };
-  httpJson?: BodyParser.OptionsJson = {
-    limit: '50mb',
-  };
-  httpsUrlencoded?: BodyParser.OptionsUrlencoded = {
-    limit: '50mb',
-    extended: true,
-  };
-  httpsJson?: BodyParser.OptionsJson = {
-    limit: '50mb',
-  };
-
-  constructor(
-    set?: DyNTS_Http_Settings
-  ) {
-    if (set) {
-      Object.assign(this, set);
-    }
-  }
-}