@futdevpro/nts-dynamo 1.14.79 → 1.14.81

package/src/_modules/bot/_modules/discord-bot/_services/dib-messaging-provider.control-service.ts

@@ -1,5 +1,5 @@
 import { Client, GatewayIntentBits, Guild, Collection, GuildMember, Message, Partials, Role, TextChannel, Channel, DMChannel } from 'discord.js';
-import { DyFM_AnyError, DyFM_Error, DyFM_Log, week } from '@futdevpro/fsm-dynamo';
+import { DyFM_AnyError, DyFM_Array, DyFM_Error, DyFM_Log, week } from '@futdevpro/fsm-dynamo';
 import { DyNTS_Bot_MessagingProvider_ServiceBase, DyNTS_Bot_MessagingProvider_Config } from '../../../_services/bot-messaging-provider.service-base';
 import { DyNTS_Bot_LastMessageDate } from '../../../_models/bot-last-message-date.interface';
 import { DyNTS_Bot_LastMentionDate } from '../../../_models/bot-last-mention-date.interface';
@@ -115,7 +115,7 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
 
   async getChannelByName(name: string): Promise<DyNTS_DiB_Channel> {
     if (this.channelCache.has(name)) {
-      return this.wrapChannel(this.channelCache.get(name));
+      return await this.wrapChannel(this.channelCache.get(name));
     }
 
     const channel = this.guild.channels.cache.find(
@@ -127,7 +127,7 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     }
 
     this.channelCache.set(name, channel);
-    return this.wrapChannel(channel);
+    return await this.wrapChannel(channel);
   }
 
   async getChannelById(id: string): Promise<DyNTS_DiB_Channel> {
@@ -139,7 +139,7 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     if (!this.channelCache.has(channel.name)) {
       this.channelCache.set(channel.name, channel);
     }
-    return this.wrapChannel(channel);
+    return await this.wrapChannel(channel);
   }
 
   async sendMessageToChannelByName(channelName: string, message: string): Promise<DyNTS_DiB_Message> {
@@ -190,7 +190,7 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
       limit: limit
     });
 
-    return Array.from(messages.values()).map((msg: Message) => this.wrapMessage(msg));
+    return await Promise.all(Array.from(messages.values()).map(async (msg: Message) => await this.wrapMessage(msg)));
   }
 
   async getLastMessageInChannel(channelName: string): Promise<DyNTS_DiB_Message> {
@@ -205,7 +205,7 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     });
     const lastMessage: Message = messages.first();
 
-    return lastMessage ? this.wrapMessage(lastMessage) : null;
+    return lastMessage ? await this.wrapMessage(lastMessage) : null;
   }
 
   async clearChannel(channel: DyNTS_DiB_Channel): Promise<void> {
@@ -261,10 +261,10 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
       }
 
       firstMessage.content = originalContent;
-      return this.wrapMessage(firstMessage);
+      return await this.wrapMessage(firstMessage);
     } else {
       const message: Message = await discordTextChannel.send(content);
-      return this.wrapMessage(message);
+      return await this.wrapMessage(message);
     }
   }
 
@@ -295,10 +295,10 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
         }
 
         firstMessage.content = originalContent;
-        return this.wrapMessage(firstMessage);
+        return await this.wrapMessage(firstMessage);
       } else {
         const reply: Message= await message.rawPlatformMessage.reply(content);
-        return this.wrapMessage(reply);
+        return await this.wrapMessage(reply);
       }
     } catch (error) {
       DyFM_Error.logSimple('Error replying to message:', error);
@@ -334,7 +334,7 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     const messages: Collection<string, Message> = await (channel.rawPlatformChannel as TextChannel).messages.fetch({ 
       limit: limit
     });
-    return Array.from(messages.values()).map((msg: Message) => this.wrapMessage(msg));
+    return await Promise.all(Array.from(messages.values()).map(async (msg: Message) => await this.wrapMessage(msg)));
   }
 
   async fetchMessagesById(id: string, limit: number): Promise<DyNTS_DiB_Message[]> {
@@ -350,7 +350,7 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     const messages: Collection<string, Message> = await message.rawPlatformMessage.channel.messages.fetch({ 
       limit: limit
     });
-    return Array.from(messages.values()).map((msg: Message) => this.wrapMessage(msg));
+    return await Promise.all(Array.from(messages.values()).map(async (msg: Message) => await this.wrapMessage(msg)));
   }
 
   async fetchAllMessagesWithPaging(channel: DyNTS_DiB_Channel, maxFetch: number = 1000): Promise<DyNTS_DiB_Message[]> {
@@ -369,9 +369,12 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
       const messageCollection: Collection<string, Message> = await channel.rawPlatformChannel.messages.fetch(options);
       if (messageCollection.size === 0) break;
 
-      Array.from(messageCollection.values()).forEach((msg: Message) => {
-        allMessages.push(this.wrapMessage(msg));
-      });
+      await DyFM_Array.asyncForEach(
+        Array.from(messageCollection.values()), 
+        async (msg: Message) => {
+          allMessages.push(await this.wrapMessage(msg));
+        }
+      );
 
       lastId = Array.from(messageCollection.values()).pop()?.id;
       fetched += messageCollection.size;
@@ -392,7 +395,7 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
       throw new Error(`User not found with username: ${username}`);
     }
 
-    return this.wrapUser(member);
+    return await this.wrapUser(member);
   }
 
   getUserMention(userId: string): string {
@@ -408,7 +411,10 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
       (channel.rawPlatformChannel as TextChannel).permissionsFor(member)?.has('ViewChannel')
     );
 
-    return Array.from(allowedMembers.values()).map((member: GuildMember) => this.wrapUser(member));
+    return await DyFM_Array.asyncMap(
+      Array.from(allowedMembers.values()), 
+      async (member: GuildMember) => await this.wrapUser(member)
+    );
   }
 
   async fetchMembersInGuild(guild: Guild): Promise<Collection<string, GuildMember>> {
@@ -545,9 +551,9 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     return pings.join(' ');
   }
 
-  create_onMessageEventListener(handler: (message: DyNTS_DiB_Message, issuer: string) => void): void {
-    this.client.on('messageCreate', (message: Message) => {
-      handler(this.wrapMessage(message), 'discord');
+  async create_onMessageEventListener(handler: (message: DyNTS_DiB_Message, issuer: string) => Promise<void>): Promise<void> {
+    this.client.on('messageCreate', async (message: Message) => {
+      await handler(await this.wrapMessage(message), 'discord');
     });
   }
 
@@ -569,7 +575,7 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     );
   }
 
-  wrapMessage(message: Message): DyNTS_DiB_Message {
+  async wrapMessage(message: Message): Promise<DyNTS_DiB_Message> {
     let replyTo: Message | null = null;
     if (message.reference?.messageId) {
       replyTo = message.channel.messages.cache.get(
@@ -597,14 +603,14 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
 
       issuer: message.author.id,
 
-      channel: this.wrapChannel(message.channel),
+      channel: await this.wrapChannel(message.channel),
       /* user: this.wrapUser(message.author), */
 
       provider: this,
     });
   }
 
-  wrapChannel(channel: Channel): DyNTS_DiB_Channel {
+  async wrapChannel(channel: Channel): Promise<DyNTS_DiB_Channel> {
     return new DyNTS_Bot_ChannelWrapper<Channel>({
       id: channel.id,
       name: (channel as TextChannel).name || ('DM Channel with ' + (channel as DMChannel).recipient.username),
@@ -617,7 +623,7 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     });
   }
 
-  wrapUser(user: GuildMember): DyNTS_DiB_User {
+  async wrapUser(user: GuildMember): Promise<DyNTS_DiB_User> {
     return new DyNTS_Bot_UserWrapper<GuildMember>({
       id: user.user.id,
       username: user.user.username,

package/src/_modules/bot/_modules/dynamo-bot/_services/dyb-messaging-provider.control-service.ts

@@ -1,4 +1,4 @@
-import { DyFM_AnyError, DyFM_Error, DyFM_Log, week } from '@futdevpro/fsm-dynamo';
+import { DyFM_AnyError, DyFM_Array, DyFM_Error, DyFM_Log, week } from '@futdevpro/fsm-dynamo';
 import { 
   DyFM_Msg_Provider_Type, DyFM_Msg_Conversation, DyFM_Msg_EventKey, DyFM_Msg_Message, DyFM_Msg_Participant 
 } from '@futdevpro/fsm-dynamo/messaging';
@@ -95,7 +95,7 @@ export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
   // Channel operations
   async getChannelByName(name: string): Promise<DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>> {
     if (this.channelCache.has(name)) {
-      return this.wrapChannel(this.channelCache.get(name));
+      return await this.wrapChannel(this.channelCache.get(name));
     }
 
     const conversationService: DyNTS_Msg_Conversation_DataService = new DyNTS_Msg_Conversation_DataService({
@@ -116,12 +116,12 @@ export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     }
 
     this.channelCache.set(name, conversation);
-    return this.wrapChannel(conversation);
+    return await this.wrapChannel(conversation);
   }
 
   async getChannelById(id: string): Promise<DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>> {
     if (this.channelCache.has(id)) {
-      return this.wrapChannel(this.channelCache.get(id));
+      return await this.wrapChannel(this.channelCache.get(id));
     }
 
     const conversationService: DyNTS_Msg_Conversation_DataService = new DyNTS_Msg_Conversation_DataService({
@@ -138,13 +138,13 @@ export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     }
 
     this.channelCache.set(id, conversation);
-    return this.wrapChannel(conversation);
+    return await this.wrapChannel(conversation);
   }
 
   async sendMessageToChannel(channel: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>, message: string, issuer: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
     const msg: DyFM_Msg_Message = await this.messaging_CS.sendMessage(channel.id, { content: message }, this.botId, issuer);
 
-    return this.wrapMessage(msg);
+    return await this.wrapMessage(msg);
   }
 
   async sendMessageToChannelByName(channelName: string, message: string, issuer: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
@@ -200,7 +200,7 @@ export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
       $limit: limit
     });
 
-    return messages.map((msg: DyFM_Msg_Message) => this.wrapMessage(msg));
+    return await DyFM_Array.asyncMap(messages, async (msg: DyFM_Msg_Message) => await this.wrapMessage(msg));
   }
 
   async fetchMessagesById(id: string, limit: number): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[]> {
@@ -215,7 +215,7 @@ export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
       $limit: limit
     });
 
-    return messages.map((msg: DyFM_Msg_Message) => this.wrapMessage(msg));
+    return await DyFM_Array.asyncMap(messages, async (msg: DyFM_Msg_Message) => await this.wrapMessage(msg));
   }
 
   async fetchMessagesForMessage(messageWrapper: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>, limit: number): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[]> {
@@ -244,7 +244,7 @@ export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
       joinedAt: new Date()
     };
 
-    return this.wrapUser(userData);
+    return await this.wrapUser(userData);
   }
 
   getUserMention(userId: string): string {
@@ -255,7 +255,7 @@ export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
     const participants: DyFM_Msg_Participant[] = channelWrapper.rawPlatformChannel.participants || [];
     
-    return participants.map(participant => this.wrapUser(participant));
+    return await DyFM_Array.asyncMap(participants, async (participant: DyFM_Msg_Participant) => await this.wrapUser(participant));
   }
 
   async readMemberNamesInChannel(channelName: string): Promise<string[]> {
@@ -364,9 +364,9 @@ export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
   }
 
   // Event binding
-  create_onMessageEventListener(
-    handler: (message: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>, issuer: string) => void
-  ): void {
+  async create_onMessageEventListener(
+    handler: (message: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>, issuer: string) => Promise<void>
+  ): Promise<void> {
     // TODO: Implement message event listener for messaging system
     DyFM_Log.info('Message event listener created (messaging integration)');
   }
@@ -389,7 +389,7 @@ export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     );
   }
 
-  wrapMessage(msgMessage: DyFM_Msg_Message): DyNTS_Bot_MessageWrapper<DyFM_Msg_Message> {
+  async wrapMessage(msgMessage: DyFM_Msg_Message): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
     return new DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>({
       id: msgMessage._id,
       content: msgMessage.content,
@@ -418,10 +418,10 @@ export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     });
   }
 
-  wrapChannel(conversation: any): DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> {
+  async wrapChannel(conversation: DyFM_Msg_Conversation): Promise<DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>> {
     return new DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>({
-      id: conversation._id || conversation.id,
-      name: conversation.name || conversation.platformChannelId || 'unknown',
+      id: conversation._id,
+      name: conversation.title || conversation.platformChannelId || 'unknown',
       isTextBased: true,
       isDM: conversation.type === 'direct',
       isVoiceBased: false,
@@ -430,12 +430,12 @@ export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     });
   }
 
-  wrapUser(user: any): DyNTS_Bot_UserWrapper<DyFM_Msg_Participant> {
+  async wrapUser(user: DyFM_Msg_Participant): Promise<DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>> {
     return new DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>({
-      id: user.userId || user.id,
-      username: user.username || user.userId || user.id,
-      displayName: user.displayName || user.username || user.userId,
-      isBot: user.isBot || false,
+      id: user.userId,
+      username: user.username,
+      displayName: user.displayName,
+      isBot: false,
       rawPlatformUser: user,
       provider: this
     });

package/src/_modules/bot/_modules/slack-bot/_services/slb-messaging-provider.control-service.ts

@@ -161,9 +161,9 @@ export class DyNTS_SlB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
   }
 
   // Event binding
-  create_onMessageEventListener(
-    handler: (message: DyNTS_Bot_MessageWrapper<SlackMessage>, issuer: string) => void
-  ): void {
+  async create_onMessageEventListener(
+    handler: (message: DyNTS_Bot_MessageWrapper<SlackMessage>, issuer: string) => Promise<void>
+  ): Promise<void> {
     throw new Error('Slack provider not yet implemented');
   }
 
@@ -179,15 +179,15 @@ export class DyNTS_SlB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     throw new Error('Slack provider not yet implemented');
   }
 
-  wrapMessage(message: SlackMessage): DyNTS_Bot_MessageWrapper<SlackMessage> {
+  wrapMessage(message: SlackMessage): Promise<DyNTS_Bot_MessageWrapper<SlackMessage>> {
     throw new Error('Slack provider not yet implemented');
   }
 
-  wrapChannel(channel: SlackChannel): DyNTS_Bot_ChannelWrapper<SlackChannel> {
+  wrapChannel(channel: SlackChannel): Promise<DyNTS_Bot_ChannelWrapper<SlackChannel>> {
     throw new Error('Slack provider not yet implemented');
   }
 
-  wrapUser(user: SlackUser): DyNTS_Bot_UserWrapper<SlackUser> {
+  wrapUser(user: SlackUser): Promise<DyNTS_Bot_UserWrapper<SlackUser>> {
     throw new Error('Slack provider not yet implemented');
   }
 }

package/src/_modules/bot/_modules/teams-bot/_services/teb-messaging-provider.control-service.ts

@@ -161,9 +161,9 @@ export class DyNTS_TeB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
   }
 
   // Event binding
-  create_onMessageEventListener(
-    handler: (message: DyNTS_Bot_MessageWrapper<TeamsMessage>, issuer: string) => void
-  ): void {
+  async create_onMessageEventListener(
+    handler: (message: DyNTS_Bot_MessageWrapper<TeamsMessage>, issuer: string) => Promise<void>
+  ): Promise<void> {
     throw new Error('Teams provider not yet implemented');
   }
 
@@ -179,15 +179,15 @@ export class DyNTS_TeB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
     throw new Error('Teams provider not yet implemented');
   }
 
-  wrapMessage(message: TeamsMessage): DyNTS_Bot_MessageWrapper<TeamsMessage> {
+  wrapMessage(message: TeamsMessage): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
     throw new Error('Teams provider not yet implemented');
   }
 
-  wrapChannel(channel: TeamsChannel): DyNTS_Bot_ChannelWrapper<TeamsChannel> {
+  wrapChannel(channel: TeamsChannel): Promise<DyNTS_Bot_ChannelWrapper<TeamsChannel>> {
     throw new Error('Teams provider not yet implemented');
   }
 
-  wrapUser(user: TeamsUser): DyNTS_Bot_UserWrapper<TeamsUser> {
+  wrapUser(user: TeamsUser): Promise<DyNTS_Bot_UserWrapper<TeamsUser>> {
     throw new Error('Teams provider not yet implemented');
   }
 }

package/src/_modules/bot/_services/bot-main.control-service.ts

@@ -202,9 +202,9 @@ export abstract class DyNTS_Bot_Main_ControlService<
         DyFM_Log.success(`${provider.name} Error event registered`);
       }
 
-      provider.create_onMessageEventListener((message: DyNTS_Bot_MessageWrapper<any>, messageIssuer: string) => {
+      provider.create_onMessageEventListener(async (message: DyNTS_Bot_MessageWrapper<any>, messageIssuer: string) => {
         try {
-          this.botIO_CS._handleNewMessage(message, messageIssuer)
+          await this.botIO_CS._handleNewMessage(message, messageIssuer)
         } catch (error) {
           DyFM_Error.logSimple(`${provider.name} error handling new message:`, error);
           DyNTS_GlobalService.globalErrorHandler(error);

package/src/_modules/bot/_services/bot-messaging-provider.service-base.ts

@@ -133,17 +133,17 @@ export abstract class DyNTS_Bot_MessagingProvider_ServiceBase<
   //  /* handler: (message: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, issuer: string, providerId?: string) => void */
   //): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>; /* void; */
   abstract create_onMessageEventListener(
-    handler: (message: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, issuer: string) => void
-  ): void;
+    handler: (message: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, issuer: string) => Promise<void>
+  ): Promise<void>;
   //abstract create_onReadyEventListener(handler: () => void): void;
   abstract create_onErrorEventListener(handler: (error: DyFM_AnyError) => void): void;
 
   abstract sendReport(message: string): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>;
   abstract sendReportIn(message: string): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>;
 
-  abstract wrapMessage(message: T_MessagingPlatformMessage): DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>;
-  abstract wrapChannel(channel: T_MessagingPlatformChannel): DyNTS_Bot_ChannelWrapper<T_MessagingPlatformChannel>;
-  abstract wrapUser(user: T_MessagingPlatformUser): DyNTS_Bot_UserWrapper<T_MessagingPlatformUser>;
+  abstract wrapMessage(message: T_MessagingPlatformMessage): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>;
+  abstract wrapChannel(channel: T_MessagingPlatformChannel): Promise<DyNTS_Bot_ChannelWrapper<T_MessagingPlatformChannel>>;
+  abstract wrapUser(user: T_MessagingPlatformUser): Promise<DyNTS_Bot_UserWrapper<T_MessagingPlatformUser>>;
   
   /* abstract channelIsTextBased(channel: T_MessagingPlatformChannel): boolean;
   abstract channelIsVoiceBased(channel: T_MessagingPlatformChannel): boolean;

package/src/_modules/defaults/_collections/default-endpoints.util.ts

@@ -67,6 +67,35 @@ export class DyNTS_DefaultEndpoints_Util {
     });
   }
 
+  static getGetMyEndpoint<T_Data extends DyFM_Metadata>(
+    set: {
+      entityName: string;
+      dataServiceClass: new (set: { data?: T_Data; issuer: string }) => DyNTS_DataService<T_Data>;
+      endpointPath: string;
+      authService: { authenticate_tokenSelf: (req: Request, res: Response) => Promise<void> };
+    }
+  ): DyNTS_Endpoint_Params {
+    const endpointName: string = `getMy${set.entityName}s`;
+
+    return new DyNTS_Endpoint_Params({
+      name: endpointName,
+      type: DyFM_HttpCallType.get,
+      endpoint: set.endpointPath,
+      preProcesses: [set.authService.authenticate_tokenSelf],
+      tasks: [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          const dataService: DyNTS_DataService<T_Data> = new set.dataServiceClass({
+            issuer: issuer,
+          });
+
+          const dataList: T_Data[] = await dataService.getDataListByDependencyId({ userId: req.params.userId });
+
+          res.send(dataService.getProvidedDataList(dataList));
+        },
+      ],
+    });
+  }
+
   /**
    * POST endpoint létrehozása adatok kereséséhez.
    * 
@@ -111,9 +140,7 @@ export class DyNTS_DefaultEndpoints_Util {
 
           const searchResults: DyFM_SearchResult<T_Data> = await dataService.searchData(req.body);
 
-          searchResults.results = searchResults.results.map((data: T_Data): T_Data => {
-            return dataService.getProvidedData(data);
-          });
+          searchResults.results = dataService.getProvidedDataList(searchResults.results);
 
           res.send(searchResults);
         },
@@ -320,7 +347,8 @@ export class DyNTS_DefaultEndpoints_Util {
       entityName: string;
       dataServiceClass: new (set: { data?: T_Data; issuer: string }) => DyNTS_DataService<T_Data>;
       endpoints: {
-        get: string;
+        get?: string;
+        getMy?: string;
         search?: string;
         modify: string;
         patch?: string;
@@ -330,43 +358,64 @@ export class DyNTS_DefaultEndpoints_Util {
       idParamName?: string;
     }
   ): DyNTS_Endpoint_Params[] {
-    return [
-      this.getGetEndpoint<T_Data>({
+    const endpoints: DyNTS_Endpoint_Params[] = [];
+
+    if (set.endpoints.get) {
+      endpoints.push(this.getGetEndpoint<T_Data>({
         entityName: set.entityName,
         dataServiceClass: set.dataServiceClass,
         endpointPath: set.endpoints.get,
         authService: set.authService,
         idParamName: set.idParamName,
-      }),
-      this.getSearchEndpoint<T_Data>({
+      }));
+    }
+
+    if (set.endpoints.getMy) {
+      endpoints.push(this.getGetMyEndpoint<T_Data>({
+        entityName: set.entityName,
+        dataServiceClass: set.dataServiceClass,
+        endpointPath: set.endpoints.getMy,
+        authService: set.authService,
+      }));
+    }
+
+    if (set.endpoints.search) {
+      endpoints.push(this.getSearchEndpoint<T_Data>({
         entityName: set.entityName,
         dataServiceClass: set.dataServiceClass,
         endpointPath: set.endpoints.search,
         authService: set.authService,
-      }),
-      this.getModifyEndpoint<T_Data>({
+      }));
+    }
+
+    if (set.endpoints.modify) {
+      endpoints.push(this.getModifyEndpoint<T_Data>({
         entityName: set.entityName,
         dataServiceClass: set.dataServiceClass,
         endpointPath: set.endpoints.modify,
         authService: set.authService,
-      }),
-      ...(set.endpoints.patch ? [
-        this.getPatchEndpoint<T_Data>({
-          entityName: set.entityName,
-          dataServiceClass: set.dataServiceClass,
-          endpointPath: set.endpoints.patch,
-          authService: set.authService,
-        }),
-      ] : []),
-      ...(set.endpoints.delete ? [
-        this.getDeleteEndpoint<T_Data>({
-          entityName: set.entityName,
-          dataServiceClass: set.dataServiceClass,
-          endpointPath: set.endpoints.delete,
-          authService: set.authService,
-          idParamName: set.idParamName,
-        }),
-      ] : []),
-    ];
+      }));
+    }
+    
+    if (set.endpoints.patch) {
+      endpoints.push(this.getPatchEndpoint<T_Data>({
+        entityName: set.entityName,
+        dataServiceClass: set.dataServiceClass,
+        endpointPath: set.endpoints.patch,
+        authService: set.authService,
+      }));
+    }
+
+    if (set.endpoints.delete) {
+      endpoints.push(this.getDeleteEndpoint<T_Data>({
+        entityName: set.entityName,
+        dataServiceClass: set.dataServiceClass,
+        endpointPath: set.endpoints.delete,
+        authService: set.authService,
+        idParamName: set.idParamName,
+      }));
+    }
+
+    return endpoints;
   }
 }

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

@@ -2482,7 +2482,11 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
   getProvidedData(data: T): T {
     return data;
   }
-  
+
+  getProvidedDataList(dataList: T[]): T[] {
+    return dataList;
+  }
+
   private _getDefaultErrorSettings(
     fnName: string, 
     error: DyFM_AnyError
@@ -2504,6 +2508,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
   protected getDefaultErrorSettings(
     fnName: string, 
     error: DyFM_AnyError,
+    /** @deprecated we wont support the separate user message in the future, use the message instead */
     useMessageAsUserMessage: boolean = true,
   ): DyFM_Error_Settings {
     return {

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

@@ -16,6 +16,7 @@ export class DyNTS_SingletonService extends DyNTS_SingletonServiceBase {
     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 {

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

@@ -723,6 +723,7 @@ export class DyNTS_EmailService /* extends DyNTS_SingletonService */ {
     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,
   ): DyFM_Error_Settings {
     return {

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

@@ -442,6 +442,7 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
     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,
   ): DyFM_Error_Settings {
     return {