@futdevpro/nts-dynamo 1.15.157 → 1.15.163

package/src/_modules/ai/_modules/document-ai/_collections/dai-chunking.util.ts

@@ -1,639 +0,0 @@
-import { DyFM_Log, DyFM_Error, DyFM_AnyError, DyFM_Error_Settings } from '@futdevpro/fsm-dynamo';
-import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
-import { DyNTS_DAI_DocChunk } from '../_models/data-models/dai-doc-chunk.data-model';
-import { DyNTS_DAI_DocPage } from '../_models/data-models/dai-doc-page.data-model';
-
-
-interface DyNTS_DAI_DocChunking_Header {
-  level: number;
-  header: string;
-  index: number;
-}
-
-interface DyNTS_DAI_DocChunking_BreakPoint {
-  index: number;
-  level: number;
-}
-
-/**
- * ClickUp dokumentum chunking szolgáltatás
- * @author AI
- * @description ClickUp dokumentumok intelligens chunking-ja a leghosszabb lehetséges chunk-ok létrehozásához
- */
-export class DyNTS_DAI_DocChunking_Util {
-    
-  protected static readonly defaultErrorUserMsg: string = 
-    `We encountered an unhandled Control Service Error, ` +
-    `\nplease contact the responsible development team.`; 
-
-  /**
-   * Unified break points configuration
-   */
-  private static readonly breakPoints: { pattern: string, level: number, includeLength: number }[] = [
-    { pattern: '\n# ', level: 1, includeLength: 0 }, // Header 1 - cut before marker
-    { pattern: '\n## ', level: 2, includeLength: 0 }, // Header 2 - cut before marker
-    { pattern: '\n### ', level: 3, includeLength: 0 }, // Header 3 - cut before marker
-    { pattern: '\n#### ', level: 4, includeLength: 0 }, // Header 4 - cut before marker
-    { pattern: '\n\n', level: 0, includeLength: 2 }, // Double line break - include
-    { pattern: '\n', level: 0, includeLength: 1 }, // Single line break - include
-    { pattern: '. ', level: 0, includeLength: 2 }, // Sentence end - include
-    { pattern: ' ', level: 0, includeLength: 1 }, // Word break - include
-  ];
-
-  protected static readonly debugLog: boolean = false;
-
-  /**
-   * Markdown tartalom chunking-ja a leghosszabb lehetséges chunk-ok létrehozásához
-   * @param page - ClickUp dokumentum oldal
-   * @param issuer - Kérés kezdeményezője
-   * @returns Promise<CU_DocChunk[]> - Létrehozott chunk-ok listája
-   */
-  static async chunkMdContent<
-    T_Chunk extends DyNTS_DAI_DocChunk,
-    T_Page extends DyNTS_DAI_DocPage<T_Chunk>,
-    >(
-      page: T_Page,
-      getPageLink: (page: T_Page, issuer: string) => string,
-      issuer: string,
-      debugLog?: boolean
-  ): Promise<T_Chunk[]> {
-    try {
-      if (debugLog) {
-        DyFM_Log.info(`Chunking page "${page.name}"...`);
-      }
-
-      if (page.content.includes('#####')) {
-        DyFM_Log.warn('lvl5+ headers are not supported yet for page: ' + page.name);
-      }
-
-      if (!page.documentId) {
-        throw new DyFM_Error({
-          ...this.getDefaultErrorSettings('chunkMdContent', new Error('Page documentId is not set'), issuer),
-          errorCode: 'CCAP-CUC-CC2',
-        });
-      }
-
-      if (!page._id) {
-        throw new DyFM_Error({
-          ...this.getDefaultErrorSettings('chunkMdContent', new Error('Page _id is not set'), issuer),
-          errorCode: 'CCAP-CUC-CC3',
-        });
-      }
-
-      /* DyFM_Log.log(`Chunking page: ${page.name}\n\n`, JSON.stringify(page.content, null, 2)); */
-
-      let leftovers: string = page.content;
-      const maxChunkSize: number = DyNTS_global_settings.docChunking.maxChunkSize;
-      const maxChunkCount: number = DyNTS_global_settings.docChunking.maxChunkCount;
-      const chunks: T_Chunk[] = [];
-      let chunkIndex: number = 0;
-      let currentPosition: number = 0; // Track current position in original content
-
-      // Parse all headers to build hierarchy
-      const headerHierarchy: DyNTS_DAI_DocChunking_Header[] = this.parseHeaderHierarchy(leftovers);
-      
-      // Debug: Log parsed headers
-      /* console.log('\n=== Parsed Header Hierarchy ===');
-      headerHierarchy.forEach((header, index) => {
-        console.log(`${index}: Level ${header.level} at position ${header.index}: "${header.header}"`);
-      });
-      console.log('=== End Header Hierarchy ===\n'); */
-      
-      // Track the last headers of each level as we progress
-      const lastHeaders: Map<number, string> = new Map();
-
-      while (leftovers.length > 0 && chunkIndex < maxChunkCount) {
-        // Ha a teljes tartalom belefér egy chunk-ba, adjuk vissza az egészet
-        if (leftovers.length <= maxChunkSize) {
-          const chunkContent = leftovers.trim();
-
-          if (chunkContent.length > 0) {
-            //const chunkWithHierarchy: string = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + leftovers.length, lastHeaders);
-            //const chunkPath: string[] = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + leftovers.length, lastHeaders);
-            const headParents: string[] = this.getRelevantHeaders(headerHierarchy, currentPosition, currentPosition + leftovers.length, lastHeaders); // headerHierarchy.map(header => header.header);
-            //const allFlaggedParents: string[] = [ ...page.allFlaggedParents, ...headParents ];
-            
-            const chunk: T_Chunk = new DyNTS_DAI_DocChunk({
-              externalDocumentId: page.externalDocumentId,
-              documentId: page.documentId,
-              externalPageId: page.externalPageId,
-              pageId: page._id,
-
-              filePathParents: page.parentedPath,
-              chunkHeadParents: headParents,
-
-              allFlaggedParents: [ ...page.allFlaggedParents, ...headParents ],
-              /* path: [ ...page.parentedPath, ...headParents ].join('/'), */
-              path: page.allFlaggedParentsMerged,
-
-              documentName: page.externalDocumentId,
-              pageName: page.name,
-              pageLink: getPageLink(page, issuer),
-              chunkIndex: chunkIndex,
-              
-              chunkContent: chunkContent,
-              /* chunkOriginalContent: chunkContent,
-
-              chunkContent: chunkWithHierarchy, */
-            }) as T_Chunk;
-
-            if (this.debugLog || debugLog) {
-              DyFM_Log.H_info(
-                'Full content (before assembleChunkWithHeaders)',
-                `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
-                { chunk: chunk.chunkContent }
-              );
-            }
-
-            /* chunk.chunkContent = this.assembleChunkWithHeaders(chunk, issuer); */
-            if (this.debugLog || debugLog) {
-              DyFM_Log.H_info(
-                'Full content (after assembleChunkWithHeaders)',
-                `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
-                { 
-                  chunk: chunk.chunkContent,
-                }
-              );
-            }
-
-            /* await DyFM_Async.wait(100_000); */
-            chunks.push(chunk);
-          }
-          break;
-        }
-
-        // Keressük meg a legjobb break point-ot a maxChunkSize-n belül
-        const breakPoint: DyNTS_DAI_DocChunking_BreakPoint | null = this.findBestBreakPoint(leftovers, maxChunkSize);
-        
-        if (breakPoint && breakPoint.index > 0) {
-          // Ha találtunk break point-ot, vágjunk a marker előtt
-          const chunkContent: string = leftovers.substring(0, breakPoint.index).trim();
-          
-          // Debug: Log current state
-          /* console.log(`\n--- Creating chunk ${chunkIndex} ---`);
-          console.log(`Current position: ${currentPosition}`);
-          console.log(`Last headers:`, Object.fromEntries(lastHeaders));
-          console.log(`Chunk content preview:`, chunkContent.substring(0, 100) + '...'); */
-          
-          // Check if chunk has headers
-          //const hasHeaders: boolean = headerHierarchy.some(header => 
-          //  header.index >= currentPosition && header.index < currentPosition + breakPoint.index
-          //);
-          /* console.log(`Chunk has headers: ${hasHeaders}`); */
-          
-          //const chunkWithHierarchy: string = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + breakPoint.index, lastHeaders);
-          //const chunkPath: string[] = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + breakPoint.index, lastHeaders);
-          const headParents: string[] = this.getRelevantHeaders(headerHierarchy, currentPosition, currentPosition + breakPoint.index, lastHeaders); // headerHierarchy.map(header => header.header);
-          //const allFlaggedParents: string[] = [ ...page.allFlaggedParents, ...headParents ];
-          
-          /* console.log(`Chunk path:`, chunkPath);
-          console.log(`Chunk with hierarchy preview:`, chunkWithHierarchy.substring(0, 100) + '...'); */
-          
-          const chunk: T_Chunk = new DyNTS_DAI_DocChunk({
-            externalDocumentId: page.externalDocumentId,
-            externalPageId: page.externalPageId,
-            documentId: page.documentId,
-            pageId: page._id,
-
-            filePathParents: page.parentedPath,
-            chunkHeadParents: headParents,
-
-            allFlaggedParents: [ ...page.allFlaggedParents, ...headParents ],
-            path: [ ...page.parentedPath, ...headParents ].join('/'),
-
-            documentName: page.externalDocumentId,
-            pageName: page.name,
-            pageLink: getPageLink(page, issuer),
-            chunkIndex: chunkIndex,
-
-            chunkContent: chunkContent,
-            /* chunkOriginalContent: chunkContent,
-
-            chunkContent: chunkWithHierarchy, */
-          }) as T_Chunk;
-
-          if (this.debugLog || debugLog) {
-            DyFM_Log.H_info(
-              'Break point (before assembleChunkWithHeaders)',
-              `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
-              { chunk: chunk.chunkContent }
-            );
-          }
-          
-          /* chunk.chunkContent = this.assembleChunkWithHeaders(chunk, issuer); */
-          if (this.debugLog || debugLog) {
-            DyFM_Log.H_info(
-              'Break point (after assembleChunkWithHeaders)',
-              `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
-              { 
-                chunk: chunk.chunkContent,
-              }
-            );
-          }
-
-          chunks.push(chunk);
-          chunkIndex++;
-          currentPosition += breakPoint.index;
-          leftovers = leftovers.substring(breakPoint.index);
-          
-          // Update last headers after creating the chunk
-          this.updateLastHeaders(headerHierarchy, currentPosition, lastHeaders);
-          
-          /* console.log(`Updated last headers:`, Object.fromEntries(lastHeaders));
-          console.log(`--- End chunk ${chunkIndex - 1} ---\n`); */
-        } else {
-          // Ha nem találtunk break point-ot, használjuk a maxChunkSize-t
-          const chunkContent: string = leftovers.substring(0, maxChunkSize).trim();
-          //const chunkWithHierarchy: string = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + maxChunkSize, lastHeaders);
-          //const chunkPath: string[] = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + maxChunkSize, lastHeaders);
-          const headParents: string[] = this.getRelevantHeaders(headerHierarchy, currentPosition, currentPosition + maxChunkSize, lastHeaders); // headerHierarchy.map(header => header.header);
-          //const allFlaggedParents: string[] = [ ...page.allFlaggedParents, ...headParents ];
-          
-          const chunk: T_Chunk = new DyNTS_DAI_DocChunk({
-            externalDocumentId: page.externalDocumentId,
-            externalPageId: page.externalPageId,
-            documentId: page.documentId,
-            pageId: page._id,
-
-            filePathParents: page.parentedPath,
-            chunkHeadParents: headParents,
-
-            allFlaggedParents: [ ...page.allFlaggedParents, ...headParents ],
-            path: [ ...page.parentedPath, ...headParents ].join('/'),
-
-            documentName: page.externalDocumentId,
-            pageName: page.name,
-            pageLink: getPageLink(page, issuer),
-            chunkIndex: chunkIndex,
-
-            chunkContent: chunkContent,
-            /* chunkOriginalContent: chunkContent,
-
-            chunkContent: chunkWithHierarchy, */
-          }) as T_Chunk;
-
-          if (this.debugLog || debugLog) {
-            DyFM_Log.H_info(
-              'Max chunk size',
-              `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
-              { chunk: chunk.chunkContent }
-            );
-          }
-
-          /* chunk.chunkContent = this.assembleChunkWithHeaders(chunk, issuer); */
-          if (this.debugLog || debugLog) {
-            DyFM_Log.H_info(
-              `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
-              { 
-                chunk: chunk.chunkContent,
-              }
-            );
-          }
-
-          chunks.push(chunk);
-          chunkIndex++;
-          currentPosition += maxChunkSize;
-          leftovers = leftovers.substring(maxChunkSize);
-          
-          // Update last headers after creating the chunk
-          this.updateLastHeaders(headerHierarchy, currentPosition, lastHeaders);
-        }
-
-        // Safety check to prevent infinite loops
-        if (leftovers.length > 0 && leftovers.length >= page.content.length) {
-          throw new DyFM_Error({
-            ...this.getDefaultErrorSettings(
-              'chunkMdContent',
-              new Error('Infinite loop detected in chunking'),
-              issuer
-            ),
-            errorCode: 'CCAP-CUC-CC1',
-          });
-        }
-      }
-
-      // Log warning if we hit the chunk count limit
-      if (chunkIndex >= maxChunkCount && leftovers.length > 0) {
-        DyFM_Log.warn(
-          `⚠️  Reached maximum chunk count (${maxChunkCount}). Remaining content: ${leftovers.length} characters`,
-          {
-            pageName: page.name,
-            pageSize: page.content.length,
-          }
-        );
-      }
-
-      /* DyFM_Log.info(`✅ Created ${chunks.length} chunks`); */
-      return chunks;
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('chunkMdContent', error, issuer),
-        errorCode: 'CCAP-CUC-CP0',
-      });
-    }
-  }
-
-  /* private static assembleChunkWithHeaders(chunk: DyNTS_DAI_DocChunk, issuer: string): string {
-    try {
-      const fileHeaders = chunk.filePathParents.map(
-        (header, index) => `${'>'.repeat(index + 1)} **${header}**`
-      ).join('\n');
-      const headers = chunk.chunkHeadParents.filter(
-        path => !chunk.chunkOriginalContent.includes(path)
-      ).join('\n');
-      return `${fileHeaders}\n\n${headers}\n\n${chunk.chunkOriginalContent}`;
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('assembleChunkWithHeaders', error, issuer),
-        errorCode: 'CCAP-CUC-ACH0',
-      });
-    }
-  } */
-
-  static reassembleChunksToContent(
-    chunks: DyNTS_DAI_DocChunk[],
-    issuer: string
-  ): string {
-    try {
-      let pageContent: string = '';
-
-      for (const chunk of chunks) {
-        if (!chunk) {
-          throw new DyFM_Error({
-            ...this.getDefaultErrorSettings(
-              'reassembleChunksToContent', 
-              new Error('Chunk is null, you`ve passing null chunks to the function'), 
-              issuer
-            ),
-            errorCode: 'CCAP-CUC-RCTC0',
-
-            additionalContent: {
-              chunks: chunks,
-            },
-          });
-        }
-
-        pageContent += chunk.chunkContent;
-      }
-
-      return pageContent;
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('reassembleChunks', error, issuer),
-        errorCode: 'CCAP-CUC-RC0',
-      });
-    }
-  }
-
-  /**
-   * Find the best break point within the chunk size
-   * @param text - The text to search in
-   * @param maxIndex - Maximum index to search up to
-   * @returns The best break point or null if not found
-   */
-  private static findBestBreakPoint(text: string, maxIndex: number): DyNTS_DAI_DocChunking_BreakPoint | null {
-    for (const breakPoint of this.breakPoints) {
-      const index: number = this.findLastOccurrence(text, breakPoint.pattern, maxIndex);
-
-      if (index > 0) {
-        return {
-          index: index + breakPoint.includeLength,
-          level: breakPoint.level
-        };
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Parse header hierarchy from the content
-   * @param content - The content to parse
-   * @returns Array of header positions and levels
-   */
-  private static parseHeaderHierarchy(content: string): DyNTS_DAI_DocChunking_Header[] {
-    const headers: DyNTS_DAI_DocChunking_Header[] = [];
-    const lines: string[] = content.split('\n');
-    let currentIndex: number = 0;
-
-    for (const line of lines) {
-      const trimmedLine: string = line.trim();
-      
-      // Check if line starts with # and determine the level
-      if (trimmedLine.startsWith('#')) {
-        const match: RegExpMatchArray | null = trimmedLine.match(/^(#+)\s+(.+)$/);
-
-        if (match) {
-          const level: number = match[1].length; // Count the number of # symbols
-          const headerText: string = trimmedLine;
-          
-          if (level >= 1 && level <= 4) { // Only support levels 1-4
-            headers.push({
-              index: currentIndex,
-              level: level,
-              header: headerText
-            });
-          }
-        }
-      }
-      
-      currentIndex += line.length + 1; // +1 for the newline
-    }
-
-    return headers;
-  }
-
-  /**
-   * Update the last headers map based on current position
-   * @param headerHierarchy - The parsed header hierarchy
-   * @param currentPosition - Current position in content
-   * @param lastHeaders - Map to store last headers of each level
-   */
-  private static updateLastHeaders(
-    headerHierarchy: DyNTS_DAI_DocChunking_Header[],
-    currentPosition: number,
-    lastHeaders: Map<number, string>
-  ): void {
-    // Find all headers that come before current position (not including current position)
-    for (const header of headerHierarchy) {
-      if (header.index < currentPosition) {
-        // Set this header as the last header for its level
-        lastHeaders.set(header.level, header.header);
-        
-        // Clear all lower level headers (higher level numbers) when any header comes
-        // For example, if we see a level 2 header, clear levels 3, 4
-        // If we see a level 1 header, clear levels 2, 3, 4
-        for (let level: number = header.level + 1; level <= 4; level++) {
-          lastHeaders.delete(level);
-        }
-      }
-    }
-  }
-
-  /**
-   * Visszaadja a chunk-hoz tartozó releváns szülő fejléceket a hierarchia alapján.
-   * @param headerHierarchy - A feldolgozott fejléc-hierarchia
-   * @param startIndex - A chunk kezdőindexe az eredeti tartalomban
-   * @param endIndex - A chunk végindexe az eredeti tartalomban
-   * @param lastHeaders - Az utolsó ismert fejlécek szintenként
-   * @returns A releváns szülő fejlécek tömbje
-   */
-  private static getRelevantHeaders(
-    headerHierarchy: DyNTS_DAI_DocChunking_Header[],
-    startIndex: number,
-    endIndex: number,
-    lastHeaders: Map<number, string>
-  ): string[] {
-    // Keressük meg az első fejlécet a chunkban
-    const firstHeaderInChunk: DyNTS_DAI_DocChunking_Header | undefined = headerHierarchy.find(header => 
-      header.index >= startIndex && header.index < endIndex
-    );
-
-    if (!firstHeaderInChunk) {
-      // Nincs fejléc a chunkban, a legmagasabb szintű utolsó fejlécet használjuk
-      let highestLevel: number = 0;
-      let highestHeader: string = '';
-
-      for (const [level, header] of lastHeaders.entries()) {
-        if (level > highestLevel) {
-          highestLevel = level;
-          highestHeader = header;
-        }
-      }
-      return highestHeader ? [highestHeader] : [];
-    }
-
-    // Szülő fejlécek összegyűjtése az első fejléc szintje alapján
-    const relevantHeaders: string[] = [];
-    for (let level: number = 1; level < firstHeaderInChunk.level; level++) {
-      const parentHeader: string | undefined = lastHeaders.get(level);
-
-      if (parentHeader) {
-        relevantHeaders.push(parentHeader);
-      }
-    }
-    return relevantHeaders;
-  }
-
-  /**
-   * Build hierarchical chunk path based on header structure
-   * @param pageName - The page name
-   * @param headerHierarchy - The parsed header hierarchy
-   * @param startIndex - Start index of the chunk in original content
-   * @param endIndex - End index of the chunk in original content
-   * @param lastHeaders - Map of last headers for each level
-   * @returns Hierarchical path array
-   */
-  private static buildChunkPath(
-    pageName: string,
-    headerHierarchy: DyNTS_DAI_DocChunking_Header[],
-    startIndex: number,
-    endIndex: number,
-    lastHeaders: Map<number, string>
-  ): string[] {
-    // Find the first header within this chunk
-    const firstHeaderInChunk: DyNTS_DAI_DocChunking_Header | undefined = headerHierarchy.find(header => 
-      header.index >= startIndex && header.index < endIndex
-    );
-
-    if (!firstHeaderInChunk) {
-      // No header in chunk, use the highest level from lastHeaders as parent
-      const pathParts: string[] = [pageName];
-      
-      // Find the highest level header from lastHeaders
-      let highestLevel: number = 0;
-      let highestHeader: string = '';
-
-      for (const [level, header] of lastHeaders.entries()) {
-        if (level > highestLevel) {
-          highestLevel = level;
-          highestHeader = header;
-        }
-      }
-      
-      if (highestHeader) {
-        pathParts.push(highestHeader);
-      }
-      
-      return pathParts;
-    }
-
-    // Build the path hierarchy
-    const pathParts: string[] = [pageName];
-    
-    // Add parent headers from lastHeaders (these are the actual parent headers)
-    for (let level = 1; level < firstHeaderInChunk.level; level++) {
-      const parentHeader: string | undefined = lastHeaders.get(level);
-
-      if (parentHeader) {
-        pathParts.push(parentHeader); // Include the full header with markdown symbols
-      }
-    }
-
-    // Add the first header in chunk
-    pathParts.push(firstHeaderInChunk.header); // Include the full header with markdown symbols
-
-    return pathParts;
-  }
-
-  /**
-   * Add header hierarchy to the beginning of a chunk
-   * @param chunkContent - The chunk content
-   * @param headerHierarchy - The parsed header hierarchy
-   * @param startIndex - Start index of the chunk in original content
-   * @param endIndex - End index of the chunk in original content
-   * @param lastHeaders - Map of last headers for each level
-   * @returns Content with header hierarchy added
-   */
-  private static addHeaderHierarchy(
-    chunkContent: string, 
-    headerHierarchy: DyNTS_DAI_DocChunking_Header[],
-    startIndex: number,
-    endIndex: number,
-    lastHeaders: Map<number, string>
-  ): string {
-    const relevantHeaders: string[] = this.getRelevantHeaders(headerHierarchy, startIndex, endIndex, lastHeaders);
-
-    if (relevantHeaders.length > 0) {
-      return relevantHeaders.join('\n') + '\n\n' + chunkContent;
-    }
-
-    return chunkContent;
-  }
-
-  /**
-   * Helper method to find the last occurrence of a pattern within a specified range
-   * @param text - The text to search in
-   * @param pattern - The pattern to search for
-   * @param maxIndex - Maximum index to search up to
-   * @returns The index of the last occurrence, or -1 if not found
-   */
-  private static findLastOccurrence(text: string, pattern: string, maxIndex: number): number {
-    const searchText: string = text.substring(0, maxIndex);
-    const lastIndex: number = searchText.lastIndexOf(pattern);
-
-    return lastIndex;
-  }
-  
-  protected static getDefaultErrorSettings(
-    fnName: string, 
-    error: DyFM_AnyError,
-    issuer: string,
-    /** @deprecated we wont support the separate user message in the future, use the message instead */
-    useMessageAsUserMessage: boolean = true,
-    /* errorCode: string, */
-  ): DyFM_Error_Settings {
-    return {
-      status: (error as DyFM_Error)?.___status ?? 500,
-      message: (error as Error)?.message ??
-        (error as DyFM_Error)?._message ??
-        `${fnName} was UNSUCCESSFUL (${DyNTS_global_settings.systemShortCodeName})`,
-      addECToUserMsg: !(error as DyFM_Error)?.__userMessage,
-      userMessage: (error as DyFM_Error)?.__userMessage ??  
-        (useMessageAsUserMessage ? (error as Error)?.message : this.defaultErrorUserMsg),
-      /* errorCode: errorCode, */
-      issuer: issuer,
-      issuerService: this.constructor?.name,
-      error: error,
-    };
-  }
-}