@futdevpro/nts-dynamo 1.14.24 → 1.14.26

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

@@ -7,15 +7,16 @@ import { DyNTS_global_settings } from '../../../_collections/global-settings.con
 import { DyNTS_Bot_Message } from '../_models/bot-message.interface'
 import { DyNTS_Bot_Channel } from '../_models/bot-channel.interface'
 import { DyNTS_Bot_User } from '../_models/bot-user.interface'
-import { DyNTS_Bot_Provider } from '../_models/bot-provider.interface'
+import { DyNTS_Bot_MessageProvider } from '../_models/bot-message-provider.interface'
 import { DyNTS_Bot_Global_Settings } from '../_models/bot-global-settings.interface'
+import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface'
 import { DyNTS_Msg_Integration_ControlService } from '../../messaging/_services/msg-integration.control-service'
 
 export abstract class DyNTS_Bot_IO_ControlService<
   T_PlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
   T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
   T_PlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
-  T_PlatformProvider extends DyNTS_Bot_Provider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser> = DyNTS_Bot_Provider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser>
+  T_PlatformProvider extends DyNTS_Bot_MessageProvider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser> = DyNTS_Bot_MessageProvider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser>
 > extends DyNTS_SingletonService {
 
   protected abstract getMainBotControlService(): DyNTS_Bot_Main_ControlService<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_PlatformProvider>;
@@ -64,27 +65,41 @@ export abstract class DyNTS_Bot_IO_ControlService<
     }
   }
 
-  async handleNewMessage(message: T_PlatformMessage, issuer: string): Promise<void> {
+  async handleNewMessage(wrapperOrMessage: DyNTS_Bot_MessageWrapper<T_PlatformMessage> | T_PlatformMessage, issuer: string): Promise<void> {
+    // Declare variables outside try-catch for error handling
+    let wrapper: DyNTS_Bot_MessageWrapper<T_PlatformMessage>;
+    let message: T_PlatformMessage;
+    
     try {
+      // Support both wrapped messages (multi-provider) and unwrapped (backward compatibility)
+      const isWrapper = 'message' in wrapperOrMessage && 'providerId' in wrapperOrMessage;
+      wrapper = isWrapper ? wrapperOrMessage as DyNTS_Bot_MessageWrapper<T_PlatformMessage> : {
+        message: wrapperOrMessage as T_PlatformMessage,
+        providerId: 'default',
+        providerType: this.provider.getProviderName() as any,
+        provider: this.provider
+      };
+      
+      message = wrapper.message;
       const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
       
       if (botSettings?.debugLevel >= 1) {
-        DyFM_Log.H_log(`incoming message (${message.authorDisplayName}):\n${message.content}`)
+        DyFM_Log.H_log(`incoming message (${message.authorDisplayName}) [${wrapper.providerId}]:\n${message.content}`)
       }
 
-      const isForYou = await this.getMessageIsForBotToHandle(message, issuer);
+      const isForYou = await this.getMessageIsForBotToHandle(message, wrapper, issuer);
 
       if (!isForYou) {
         return;
       }
 
-      const isHandledAsCommand = await this.handleIfCommand(message, issuer);
+      const isHandledAsCommand = await this.handleIfCommand(message, wrapper, issuer);
 
       if (isHandledAsCommand) {
         return;
       }
 
-      await this.handleMessage(message, issuer);
+      await this.handleMessage(message, wrapper, issuer);
       
       // Sync message to messaging system if enabled
       try {
@@ -94,7 +109,7 @@ export abstract class DyNTS_Bot_IO_ControlService<
           // Find or create conversation for this channel
           const conversation = await messagingIntegration.findOrCreateBotConversation(
             message.channelId,
-            this.provider.getProviderName(),
+            wrapper.providerType,
             issuer
           );
           
@@ -115,14 +130,20 @@ export abstract class DyNTS_Bot_IO_ControlService<
       const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
       
       if (!this.dontSendErrorReply && botSettings?.debugLevel >= 1) {
-        await this.provider.replyToMessage(
-          message.id,
-          message.channelId,
-          `[SYSTEM|ERROR|${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-H0] Error occurred while handling the message:\n` +
-          DyFM_Error.getAnyMessage(error)
-        ).catch(error => {
-          DyFM_Error.logSimple('❌❌ Error sending message to report channel:', error);
-        });
+        // Use wrapper if available, fallback to default provider
+        const errorProvider = wrapper?.provider || this.provider;
+        const errorMessage = wrapper?.message || message;
+        
+        if (errorProvider && errorMessage) {
+          await errorProvider.replyToMessage(
+            errorMessage.id,
+            errorMessage.channelId,
+            `[SYSTEM|ERROR|${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-H0] Error occurred while handling the message:\n` +
+            DyFM_Error.getAnyMessage(error)
+          ).catch(err => {
+            DyFM_Error.logSimple('❌❌ Error sending message to report channel:', err);
+          });
+        }
       }
 
       throw new DyFM_Error({
@@ -132,17 +153,19 @@ export abstract class DyNTS_Bot_IO_ControlService<
     }
   }
 
-  abstract handleMessage(message: T_PlatformMessage, issuer: string): Promise<T_PlatformMessage>;
+  abstract handleMessage(message: T_PlatformMessage, wrapper: DyNTS_Bot_MessageWrapper<T_PlatformMessage>, issuer: string): Promise<T_PlatformMessage>;
 
   async getMessageIsForBotToHandle(
     message: T_PlatformMessage, 
+    wrapper: DyNTS_Bot_MessageWrapper<T_PlatformMessage>,
     issuer: string, 
     dontRemovePing?: boolean
   ): Promise<boolean> {
     try {
       const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
       
-      if (!this.provider || !this.mainBot_CS || !this.botClientId) {
+      const provider = wrapper.provider || this.provider;
+      if (!provider || !this.mainBot_CS || !this.botClientId) {
         DyFM_Log.H_error(
           '🚫❌ Bot not initialized yet. END wont respond to message:', message.content,
           new Error('Bot not initialized yet').stack
@@ -184,7 +207,8 @@ export abstract class DyNTS_Bot_IO_ControlService<
         }
 
         if (!isOwnMessage && isPinged) {
-          this.provider.replyToMessage(
+          const provider = wrapper.provider || this.provider;
+          provider.replyToMessage(
             message.id,
             message.channelId,
             `[SYSTEM|REFUSE|CHANNEL] I'm sorry, but I'm not allowed to answer you in this channel!`
@@ -221,7 +245,8 @@ export abstract class DyNTS_Bot_IO_ControlService<
       ) {
         if (isPinged && botSettings?.debugLevel >= 2) {
           DyFM_Log.warn('🚫🤖❌ not for me; this message is from a bot')
-          this.provider.replyToMessage(
+          const provider = wrapper.provider || this.provider;
+          provider.replyToMessage(
             message.id,
             message.channelId,
             '[SYSTEM|REFUSE|BOT] You should not ping me!'
@@ -247,7 +272,8 @@ export abstract class DyNTS_Bot_IO_ControlService<
       if (!isAllowedUser) {
         if (botSettings?.debugLevel >= 2) {
           DyFM_Log.warn('🚫❌ not allowed user. END', message.authorName, message.authorDisplayName)
-          this.provider.replyToMessage(
+          const provider = wrapper.provider || this.provider;
+          provider.replyToMessage(
             message.id,
             message.channelId,
             `[SYSTEM|REFUSE|USER] I'm sorry, but I'm not allowed to answer you!`
@@ -274,12 +300,12 @@ export abstract class DyNTS_Bot_IO_ControlService<
     }
   }
 
-  async handleIfCommand(message: T_PlatformMessage, issuer: string): Promise<boolean> {
+  async handleIfCommand(message: T_PlatformMessage, wrapper: DyNTS_Bot_MessageWrapper<T_PlatformMessage>, issuer: string): Promise<boolean> {
     try {
       const isCommand = await this.isCommand(message, issuer);
 
       if (isCommand) {
-        await this.commands_CS.handleCommand(message, issuer);
+        await this.commands_CS.handleCommand(message, wrapper, issuer);
       }
 
       return Boolean(isCommand);

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

@@ -1,14 +1,16 @@
 import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
 import { DyFM_Async, DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
 import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_Bot_Provider } from '../_models/bot-provider.interface';
+import { DyNTS_Bot_MessageProvider, DyNTS_Bot_MessageProvider_Config } from '../_models/bot-message-provider.interface';
 import { DyNTS_Bot_Message } from '../_models/bot-message.interface';
 import { DyNTS_Bot_Channel } from '../_models/bot-channel.interface';
 import { DyNTS_Bot_User } from '../_models/bot-user.interface';
-import { DyNTS_Bot_Global_Settings } from '../_models/bot-global-settings.interface';
+import { DyNTS_Bot_Global_Settings, DyNTS_Bot_Settings } from '../_models/bot-global-settings.interface';
 import { DyNTS_GlobalService } from '../../../_services/core/global.service';
 import { DyNTS_Bot_IO_ControlService } from './bot-io.control-service';
 import { DyNTS_Bot_Routines_ControlService } from './bot-routines.control-service';
+import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface';
+import { DyNTS_Bot_Provider_Factory } from './bot-provider-factory.service';
 
 /**
  * This is the main control service for the Bot.
@@ -25,11 +27,11 @@ export abstract class DyNTS_Bot_Main_ControlService<
   T_PlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
   T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
   T_PlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
-  T_PlatformProvider extends DyNTS_Bot_Provider<
+  T_PlatformProvider extends DyNTS_Bot_MessageProvider<
     T_PlatformChannel, 
     T_PlatformMessage, 
     T_PlatformUser
-  > = DyNTS_Bot_Provider<
+  > = DyNTS_Bot_MessageProvider<
     T_PlatformChannel, 
     T_PlatformMessage, 
     T_PlatformUser
@@ -37,11 +39,20 @@ export abstract class DyNTS_Bot_Main_ControlService<
 > extends DyNTS_SingletonService {
 
   protected _provider: T_PlatformProvider;
+  protected _providers: Map<string, T_PlatformProvider> = new Map();
 
   get provider(): T_PlatformProvider {
     return this._provider;
   }
 
+  get providers(): Map<string, T_PlatformProvider> {
+    return this._providers;
+  }
+
+  getProviderById(providerId: string): T_PlatformProvider | undefined {
+    return this._providers.get(providerId);
+  }
+
   get botClientId(): string {
     return this.provider?.getBotId() ?? DyNTS_global_settings?.bot_settings?.discord?.clientId;
   }
@@ -112,11 +123,39 @@ export abstract class DyNTS_Bot_Main_ControlService<
     }
   }
 
+  /**
+   * Check if the bot is configured for multiple providers
+   */
+  protected isMultiProviderMode(): boolean {
+    const settings = DyNTS_global_settings.bot_settings as any;
+    return Array.isArray(settings?.providers) && settings.providers.length > 0;
+  }
+
+  /**
+   * Get all provider configurations (supports both single and multi-provider mode)
+   */
+  protected getProviderConfigs(): DyNTS_Bot_MessageProvider_Config[] {
+    const settings = DyNTS_global_settings.bot_settings as any;
+    
+    if (this.isMultiProviderMode()) {
+      return settings.providers;
+    } else {
+      // Single provider mode - wrap existing config
+      const config = settings as DyNTS_Bot_MessageProvider_Config;
+      if (!config.providerId) {
+        config.providerId = config.messageProvider || 'default';
+      }
+      return [config];
+    }
+  }
+
   async setup(issuer: string): Promise<void> {
     try {
       await DyFM_Async.delay(100);
 
-      if (!DyNTS_global_settings.bot_settings?.provider) {
+      const configs = this.getProviderConfigs();
+      
+      if (configs.length === 0) {
         throw new Error(
           `No bot provider configured!` +
           `\nPlease set the provider in DyNTS_global_settings.bot_settings.provider` +
@@ -124,6 +163,13 @@ export abstract class DyNTS_Bot_Main_ControlService<
         );
       }
 
+      // If multi-provider mode, initialize all providers
+      if (this.isMultiProviderMode()) {
+        await this.setupMultipleProviders(configs, issuer);
+        return;
+      }
+
+      // Single provider mode (backward compatible)
       if (!this.provider) {
         throw new Error(
           `No bot provider instance found!` +
@@ -228,6 +274,85 @@ export abstract class DyNTS_Bot_Main_ControlService<
     }
   }
 
+  private async setupMultipleProviders(
+    configs: DyNTS_Bot_MessageProvider_Config[], 
+    issuer: string
+  ): Promise<void> {
+    const providers = DyNTS_Bot_Provider_Factory.createProviders(configs);
+    this._providers = providers as Map<string, T_PlatformProvider>;
+
+    const setupPromises = Array.from(providers.entries()).map(([providerId, provider]) => {
+      return new Promise<void>((resolve, reject) => {
+        provider.onError((error) => {
+          if (DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
+            DyFM_Error.logSimple(`Bot provider error [${providerId}]:`, error);
+          }
+          DyNTS_GlobalService.globalErrorHandler(error);
+          reject(error);
+        });
+
+        provider.onReady(async () => {
+          if (DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
+            DyFM_Log.success(`Bot logged in as ${provider.getBotDisplayName()} [${providerId}]`);
+          }
+          resolve();
+        });
+
+        provider.onMessage((message, messageIssuer, msgProviderId) => {
+          try {
+            const wrapper: DyNTS_Bot_MessageWrapper<T_PlatformMessage> = {
+              message: message as T_PlatformMessage,
+              providerId: msgProviderId || provider.getProviderId() || providerId,
+              providerType: provider.getProviderName() as any,
+              provider: provider as any
+            };
+            
+            this.botIO_CS.handleNewMessage(wrapper, messageIssuer)
+          } catch (error) {
+            DyFM_Error.logSimple('Error handling new message:', error);
+          }
+        });
+
+        const config = configs.find(c => c.providerId === providerId);
+        if (!config) {
+          reject(new Error(`No config found for provider ${providerId}`));
+          return;
+        }
+
+        provider.initialize(config).then(() => {
+          const token = this.getTokenForProviderConfig(config);
+          return provider.login(token);
+        }).catch((error) => {
+          reject(error);
+        });
+      });
+    });
+
+    await Promise.all(setupPromises);
+
+    // Set default provider (first one) for backward compatibility
+    if (this._provider) {
+      this._provider = providers.values().next().value;
+    }
+
+    await this.start(issuer);
+    
+    DyFM_Log.success('All bot providers setup complete');
+  }
+
+  private getTokenForProviderConfig(config: DyNTS_Bot_MessageProvider_Config): string {
+    switch (config.messageProvider) {
+      case 'discord':
+        return config.discord?.token;
+      case 'slack':
+        return config.slack?.token;
+      case 'teams':
+        return config.teams?.appPassword;
+      default:
+        throw new Error(`Unsupported provider: ${config.messageProvider}`);
+    }
+  }
+
   async start(issuer: string): Promise<void> {
     try {
       this.botIO_CS = this.getBotIOControlService();

package/src/_modules/bot/_services/bot-provider-factory.service.ts

@@ -1,34 +1,56 @@
-import { DyNTS_Bot_Provider, DyNTS_Bot_Provider_Config } from '../_models/bot-provider.interface';
-import { DyNTS_Bot_Provider_Type } from '../_enums/bot-provider.enum';
-import { DyNTS_DiB_Provider } from '../_modules/discord-bot/_services/dib-provider.service';
-import { DyNTS_SlB_Provider } from '../_modules/slack-bot/_services/slb-provider.service';
-import { DyNTS_TeB_Provider } from '../_modules/teams-bot/_services/teb-provider.service';
-import { DyNTS_DyB_Provider } from '../_modules/dynamo-bot/_services/dyb-provider.service';
+import { DyNTS_Bot_MessageProvider, DyNTS_Bot_MessageProvider_Config } from '../_models/bot-message-provider.interface';
+import { DyNTS_Bot_MessageProvider_Type } from '../_enums/bot-message-provider.enum';
+import { DyNTS_DiB_MessageProvider } from '../_modules/discord-bot/_services/dib-message-provider.service';
+import { DyNTS_SlB_MessageProvider } from '../_modules/slack-bot/_services/slb-message-provider.service';
+import { DyNTS_TeB_MessageProvider } from '../_modules/teams-bot/_services/teb-message-provider.service';
+import { DyNTS_DyB_MessageProvider } from '../_modules/dynamo-bot/_services/dyb-message-provider.service';
 
 export class DyNTS_Bot_Provider_Factory {
 
-  static createProvider(config: DyNTS_Bot_Provider_Config): DyNTS_Bot_Provider {
-    switch (config.provider) {
-      case DyNTS_Bot_Provider_Type.discord:
-        return new DyNTS_DiB_Provider();
+  static createProvider(config: DyNTS_Bot_MessageProvider_Config): DyNTS_Bot_MessageProvider {
+    switch (config.messageProvider) {
+      case DyNTS_Bot_MessageProvider_Type.discord:
+        return new DyNTS_DiB_MessageProvider();
 
-      case DyNTS_Bot_Provider_Type.slack:
-        return new DyNTS_SlB_Provider();
+      case DyNTS_Bot_MessageProvider_Type.slack:
+        return new DyNTS_SlB_MessageProvider();
 
-      case DyNTS_Bot_Provider_Type.teams:
-        return new DyNTS_TeB_Provider();
+      case DyNTS_Bot_MessageProvider_Type.teams:
+        return new DyNTS_TeB_MessageProvider();
 
-      case DyNTS_Bot_Provider_Type.dynamo:
-        return new DyNTS_DyB_Provider();
+      case DyNTS_Bot_MessageProvider_Type.dynamo:
+        return new DyNTS_DyB_MessageProvider();
 
-      case DyNTS_Bot_Provider_Type.custom:
-        if (!config.providerInstance) {
+      case DyNTS_Bot_MessageProvider_Type.custom:
+        if (!config.messageProviderInstance) {
           throw new Error('Custom provider instance is required when provider type is "custom"');
         }
-        return config.providerInstance;
+        return config.messageProviderInstance;
 
       default:
-        throw new Error(`Unsupported provider type: ${config.provider}`);
+        throw new Error(`Unsupported provider type: ${config.messageProvider}`);
     }
   }
+
+  static createProviders(configs: DyNTS_Bot_MessageProvider_Config[]): Map<string, DyNTS_Bot_MessageProvider> {
+    const providers = new Map<string, DyNTS_Bot_MessageProvider>();
+    const providerIds = new Set<string>();
+
+    for (const config of configs) {
+      if (!config.providerId) {
+        throw new Error('providerId is required when using multiple providers');
+      }
+
+      if (providerIds.has(config.providerId)) {
+        throw new Error(`Duplicate providerId detected: ${config.providerId}`);
+      }
+
+      providerIds.add(config.providerId);
+
+      const provider = this.createProvider(config);
+      providers.set(config.providerId, provider);
+    }
+
+    return providers;
+  }
 }

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

@@ -8,17 +8,17 @@ import { DyNTS_global_settings } from '../../../_collections/global-settings.con
 import { DyNTS_Bot_Channel } from '../_models/bot-channel.interface';
 import { DyNTS_Bot_Message } from '../_models/bot-message.interface';
 import { DyNTS_Bot_User } from '../_models/bot-user.interface';
-import { DyNTS_Bot_Provider } from '../_models/bot-provider.interface';
+import { DyNTS_Bot_MessageProvider } from '../_models/bot-message-provider.interface';
 
 export abstract class DyNTS_Bot_Routines_ControlService<
   T_PlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
   T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
   T_PlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
-  T_PlatformProvider extends DyNTS_Bot_Provider<
+  T_PlatformProvider extends DyNTS_Bot_MessageProvider<
     T_PlatformChannel, 
     T_PlatformMessage, 
     T_PlatformUser
-  > = DyNTS_Bot_Provider<
+  > = DyNTS_Bot_MessageProvider<
     T_PlatformChannel, 
     T_PlatformMessage, 
     T_PlatformUser

package/src/_modules/bot/index.ts

@@ -6,13 +6,14 @@
 //
 
 // ENUMS
-export * from './_enums/bot-provider.enum';
+export * from './_enums/bot-message-provider.enum';
 
 // MODELS
 export * from './_models/bot-message.interface';
+export * from './_models/bot-message-wrapper.interface';
 export * from './_models/bot-channel.interface';
 export * from './_models/bot-user.interface';
-export * from './_models/bot-provider.interface';
+export * from './_models/bot-message-provider.interface';
 export * from './_models/bot-command.interface';
 export * from './_models/bot-global-settings.interface';
 export * from './_models/bot-last-message-date.interface';