@futdevpro/nts-dynamo 1.14.78 → 1.14.80

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/_services/base/data.service.ts

@@ -1989,9 +1989,15 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
               (searchString: string): string => searchString.toLowerCase()
             );
 
-            return (dataProperty: string): boolean => lowerCaseSearchValueArray.some(
-              (searchString: string): boolean => dataProperty?.toLowerCase().includes(searchString)
-            );
+            return (dataProperty: string): boolean => {
+              // Convert to string if not already a string (handles numbers, etc.)
+              const dataPropertyAsString: string = 
+                dataProperty != null ? String(dataProperty) : '';
+              return lowerCaseSearchValueArray.some(
+                (searchString: string): boolean => 
+                  dataPropertyAsString?.toLowerCase().includes(searchString)
+              );
+            };
           } else {
             const lowerCaseSearchValue: string = (searchValue as string)?.toLowerCase();
 
@@ -1999,8 +2005,12 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
               return (dataProperty: string): boolean => !dataProperty;
             }
 
-            return (dataProperty: string): boolean => 
-              dataProperty?.toLowerCase().includes(lowerCaseSearchValue);
+            return (dataProperty: string): boolean => {
+              // Convert to string if not already a string (handles numbers, etc.)
+              const dataPropertyAsString: string = 
+                dataProperty != null ? String(dataProperty) : '';
+              return dataPropertyAsString?.toLowerCase().includes(lowerCaseSearchValue);
+            };
           }
 
         case DyFM_BasicProperty_Type.date: