@futdevpro/nts-dynamo 1.15.156 → 1.15.160

package/src/_modules/bot/_models/bot-global-settings.interface.ts

@@ -1,96 +0,0 @@
-import { DyNTS_Bot_Command } from './bot-command.interface';
-import { DyNTS_Bot_MessagingProvider_Config } from '../_services/bot-messaging-provider.service-base';
-
-export interface DyNTS_Bot_Global_Settings {
-  /**
-   * this setting will set the debug level for the bot
-   * 
-   * 0 - no logs  
-   * 1 - errors sending to report channel  
-   * 2 - errors sending as response, will log events in console   
-   * 3 - errors sending as response, creating reports to report channel, debug events are in console (default)  
-   * 4 - errors and debug events are sending as response  
-   * 5 - all events are sending as response (that are set to send)  
-   * 6 - all debug logs are enabled  
-   *   
-   *   _
-   */
-  debugLevel: number;
-
-  allowedUsers: 'all' | string[];
-
-  messageSettings: {
-    /**
-     * this setting will set the time limit for message fetching
-     * so we will stop fetching messages sent later than this time
-     */
-    messageFetchTimeLimit: number;
-    /**
-     * this setting will set the count limit for message fetching
-     * so we will stop fetching messages after this count
-     */
-    messageFetchCountLimit: number;
-    /**
-     * this setting will set the delay for message sending,
-     * so we won't flood the channel too fast
-     */
-    messageSendDelay: number;
-
-    /**
-     * this setting will be used to skip answering to messages
-     * if the message contains any of these flags, the bot will not answer
-     * 
-     * @default [ '[BOT-SKIP]' ]
-     */
-    skipFlags: string[];
-  };
-
-  /**
-   * this setting will set the channel settings for the bot
-   */
-  channelSettings: {
-    /**
-     * this setting will set the name of the channel where the bot will send the reports
-     * 
-     * @default 'bot-report'
-     */
-    reportChannelName: string;
-
-    /**
-     * this setting will set the channels where the bot will answer automatically
-     * whenever a message is sent in one of these channels, that is not from the bot
-     * 
-     * it will be populated automatically from the default channels
-     */
-    allowedChannels: string[];
-    /**
-     * this setting will set if the bot can answer in Direct Messages Channels
-     * 
-     * @default false
-     */
-    dmIsAllowed: boolean;
-
-    /**
-     * this setting will set the default channels where the bot will answer automatically
-     * whenever a message is sent in one of these channels, that is not from the bot
-     * 
-     * @default [ 'bot-report' ]
-     */
-    defaultChannels: string[];
-  };
-
-  commandSettings: {
-    commandOperator: string;
-    commands: DyNTS_Bot_Command[];
-  };
-
-  allowBotsInteractEachOther: boolean;
-}
-
-export interface DyNTS_Bot_MultiMessageProvider_Settings {
-  /** Array of provider configurations (use for multiple providers) */
-  providers: DyNTS_Bot_MessagingProvider_Config[];
-}
-
-/** Union type supporting both single and multi-provider configurations */
-export type DyNTS_Bot_Settings = DyNTS_Bot_MessagingProvider_Config | (DyNTS_Bot_Global_Settings & DyNTS_Bot_MultiMessageProvider_Settings);

package/src/_modules/bot/_models/bot-last-mention-date.interface.ts

@@ -1,6 +0,0 @@
-export interface DyNTS_Bot_LastMentionDate {
-  memberId: string;
-  memberName: string;
-  allMentions: number;
-  lastMentionDate: Date | null;
-}

package/src/_modules/bot/_models/bot-last-message-date.interface.ts

@@ -1,5 +0,0 @@
-export interface DyNTS_Bot_LastMessageDate {
-  memberName: string;
-  allMessages: number;
-  lastMessageDate: Date | null;
-}

package/src/_modules/bot/_models/bot-message-wrapper.interface.ts

@@ -1,90 +0,0 @@
-import { DyNTS_Bot_MessagingProvider_ServiceBase } from '../_services/bot-messaging-provider.service-base';
-import { DyNTS_Bot_ChannelWrapper } from './bot-channel-wrapper.interface';
-import { DyNTS_Bot_UserWrapper } from './bot-user-wrapper.interface';
-
-export class DyNTS_Bot_MessageWrapper_Base<
-  T_MessagingPlatformMessage extends any = any,
-  T_MessagingPlatformChannel extends any = any,
-  /* T_MessagingPlatformUser extends any = any, */
-> {
-  id: string;
-  content: string;
-  authorId: string;
-  authorName: string;
-  authorDisplayName: string;
-  channelId: string;
-  channelName: string;
-  timestamp: number;
-  isBot: boolean;
-  isTextBased: boolean;
-  isVoiceBased: boolean;
-  isDM: boolean;
-
-  replyToMessageId: string | null;
-  replyToMessageAuthorId: string | null;
-
-  mentions: string[]; // user IDs
-  issuer: string;
-
-  rawPlatformMessage: T_MessagingPlatformMessage; // Original platform message for platform-specific operations
-
-  channel: DyNTS_Bot_ChannelWrapper<T_MessagingPlatformChannel>;
-  /* user: DyNTS_Bot_UserWrapper<T_MessagingPlatformUser>; */
-
-  /** Reference to the provider instance for sending replies */
-  provider: DyNTS_Bot_MessagingProvider_ServiceBase<
-    T_MessagingPlatformChannel,
-    T_MessagingPlatformMessage,
-    any, /* T_MessagingPlatformUser, */
-    any
-  >;
-}
-
-/**
- * Wraps a bot message with provider context
- * This ensures messages include the provider information needed to send replies
- * back through the correct platform
- */
-export class DyNTS_Bot_MessageWrapper<
-  T_MessagingPlatformMessage extends any = any,
-  T_MessagingPlatformChannel extends any = any,
-  //T_MessagingPlatformUser extends any = any,
-> extends DyNTS_Bot_MessageWrapper_Base<
-  T_MessagingPlatformMessage, 
-  T_MessagingPlatformChannel/* , 
-  T_MessagingPlatformUser */
-> {
-
-  constructor(
-    set: DyNTS_Bot_MessageWrapper_Base<
-      T_MessagingPlatformMessage, 
-      T_MessagingPlatformChannel/* , 
-      T_MessagingPlatformUser */
-    >
-  ) {
-    super();
-    
-    Object.assign(this, set);
-  }
-
-  async reply(content: string): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>> {
-    return await this.provider.replyToMessage(this, content);
-  }
-
-  async sendTyping(): Promise<void> {
-    await this.provider.sendTypingForMessage(this);
-  }
-
-  async fetchMessages(limit: number): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>[]> {
-    return await this.provider.fetchMessagesForMessage(this, limit);
-  }
-
-  async delete(): Promise<void> {
-    await this.provider.deleteMessage(this);
-  }
-
-  channelIsTextBased(): boolean {
-    return this.channel.isTextBased;
-  }
-}
-

package/src/_modules/bot/_models/bot-user-wrapper.interface.ts

@@ -1,41 +0,0 @@
-import { DyNTS_Bot_MessagingProvider_ServiceBase } from '../_services/bot-messaging-provider.service-base';
-
-/**
- * Wraps a bot user with provider context
- * This ensures users include the provider information needed for platform-specific operations
- */
-export class DyNTS_Bot_UserWrapper_Base<
-  T_MessagingPlatformUser extends any = any,
-> {
-  id: string;
-  username: string;
-  displayName: string;
-  isBot: boolean;
-
-  rawPlatformUser: T_MessagingPlatformUser;
-  
-  /** Reference to the provider instance for platform-specific operations */
-  provider:/*  T_MessagingPlatformService; */ DyNTS_Bot_MessagingProvider_ServiceBase<
-    any, //DyNTS_Bot_ChannelWrapper<any> , 
-    any, //DyNTS_Bot_MessageWrapper<any> , 
-    T_MessagingPlatformUser
-  >;
-}
-
-/**
- * Wraps a bot user with provider context
- * This ensures users include the provider information needed for platform-specific operations
- */
-export class DyNTS_Bot_UserWrapper<
-  T_MessagingPlatformUser extends any = any,
-> extends DyNTS_Bot_UserWrapper_Base<T_MessagingPlatformUser> {
-  
-  constructor(
-    set: DyNTS_Bot_UserWrapper_Base<T_MessagingPlatformUser>
-  ) {
-    super();
-    
-    Object.assign(this, set);
-  }
-}
-

package/src/_modules/bot/_modules/discord-bot/_models/dib-platform.types.ts

@@ -1,10 +0,0 @@
-/* import { Message, TextChannel, GuildMember, Channel } from 'discord.js';
-import { DyNTS_Bot_MessageWrapper } from '../../../_models/bot-message-wrapper.interface';
-import { DyNTS_Bot_ChannelWrapper } from '../../../_models/bot-channel-wrapper.interface';
-import { DyNTS_Bot_UserWrapper } from '../../../_models/bot-user-wrapper.interface';
-
-// Discord Bot Platform-Specific Types
-export type DyNTS_DiB_Message = DyNTS_Bot_MessageWrapper<Message>;
-export type DyNTS_DiB_Channel = DyNTS_Bot_ChannelWrapper<Channel>;
-export type DyNTS_DiB_User = DyNTS_Bot_UserWrapper<GuildMember>;
- */

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

@@ -1,431 +0,0 @@
-
-import { DyNTS_DiB_MessagingProvider_ControlService, Discord_MessagingProviderConfig } from './dib-messaging-provider.control-service';
-import { DyFM_Msg_Provider_Type } from '@futdevpro/fsm-dynamo/messaging';
-import { Client, GatewayIntentBits, Partials, Guild, TextChannel, Message, Collection, GuildMember, Role, User, Channel, DMChannel } from 'discord.js';
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
-
-// Skipped: DyFM_Error vs Error expectation issues
-describe('| DyNTS_DiB_MessagingProvider_ControlService', () => {
-  let provider: DyNTS_DiB_MessagingProvider_ControlService;
-  let mockClient: jasmine.SpyObj<Client>;
-  let mockGuild: jasmine.SpyObj<Guild>;
-  let mockTextChannel: jasmine.SpyObj<TextChannel>;
-  let mockMessage: jasmine.SpyObj<Message>;
-  let mockGuildMember: jasmine.SpyObj<GuildMember>;
-  let mockRole: jasmine.SpyObj<Role>;
-  let mockUser: jasmine.SpyObj<User>;
-
-  const config: Discord_MessagingProviderConfig = {
-    token: 'test-token',
-    guildId: 'guild-123',
-    clientId: 'client-123',
-    oauth2Url: 'https://oauth2.example.com',
-    intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages],
-    partials: [Partials.Message, Partials.Channel],
-    reportChannelName: 'reports',
-  };
-
-  beforeEach(() => {
-    // Create mock Discord.js objects
-    mockUser = jasmine.createSpyObj('User', [], {
-      id: 'user-123',
-      username: 'test-user',
-      displayName: 'Test User',
-      bot: false,
-    });
-
-    mockGuildMember = jasmine.createSpyObj('GuildMember', ['fetch'], {
-      user: mockUser,
-      id: 'member-123',
-      displayName: 'Test User',
-    });
-
-    mockRole = jasmine.createSpyObj('Role', [], {
-      id: 'role-123',
-      name: 'Test Role',
-    });
-
-    mockTextChannel = jasmine.createSpyObj('TextChannel', ['send', 'sendTyping', 'messages'], {
-      id: 'channel-123',
-      name: 'test-channel',
-      isTextBased: () => true,
-      isDMBased: () => false,
-      isVoiceBased: () => false,
-    });
-
-    mockMessage = jasmine.createSpyObj('Message', ['delete', 'reply'], {
-      id: 'message-123',
-      content: 'Test message',
-      author: mockUser,
-      channel: mockTextChannel,
-      createdTimestamp: Date.now(),
-      reference: null,
-      mentions: {
-        users: new Collection<string, User>(),
-      },
-    });
-
-    mockGuild = jasmine.createSpyObj('Guild', ['members.fetch'], {
-      id: 'guild-123',
-      channels: {
-        cache: new Collection<string, Channel>([
-          ['channel-123', mockTextChannel],
-        ]),
-        get: jasmine.createSpy('channels.get').and.returnValue(mockTextChannel),
-        find: jasmine.createSpy('channels.find').and.returnValue(mockTextChannel),
-      },
-      members: {
-        cache: new Collection<string, GuildMember>([
-          ['member-123', mockGuildMember],
-        ]),
-        find: jasmine.createSpy('members.find').and.returnValue(mockGuildMember),
-      },
-      roles: {
-        cache: new Collection<string, Role>([
-          ['role-123', mockRole],
-        ]),
-        find: jasmine.createSpy('roles.find').and.returnValue(mockRole),
-      },
-    });
-
-    mockClient = jasmine.createSpyObj('Client', ['login', 'on'], {
-      user: {
-        id: 'bot-123',
-        tag: 'TestBot#1234',
-        displayName: 'Test Bot',
-      },
-      guilds: {
-        cache: new Collection<string, Guild>([
-          ['guild-123', mockGuild],
-        ]),
-        get: jasmine.createSpy('guilds.get').and.returnValue(mockGuild),
-      },
-    });
-
-    provider = new DyNTS_DiB_MessagingProvider_ControlService(config);
-    (provider as any).client = mockClient;
-    (provider as any).guild = mockGuild;
-  });
-
-  describe('| constructor', () => {
-    it('| should initialize with config', () => {
-      expect(provider.config).toEqual(config);
-      expect(provider.name).toBe('discord');
-      expect(provider.type).toBe(DyFM_Msg_Provider_Type.discord);
-    });
-  });
-
-  describe('| properties', () => {
-    it('| should return botId from client user', () => {
-      expect(provider.botId).toBe('bot-123');
-    });
-
-    it('| should return botDisplayName from client user', () => {
-      expect(provider.botDisplayName).toBe('Test Bot');
-    });
-  });
-
-  describe('| setup', () => {
-    it('| should initialize Discord client', async () => {
-      spyOn(Client.prototype, 'constructor' as any).and.returnValue(mockClient);
-
-      await provider.setup('test-issuer');
-
-      expect(mockClient).toBeDefined();
-    });
-
-    // Skip - setup errors test has issues with mocking Client constructor
-    it('| should handle setup errors', async () => {
-      // Skipped - cannot reliably mock Client constructor
-    });
-  });
-
-  describe('| start', () => {
-    it('| should login and wait for ready event', async () => {
-      mockClient.login.and.returnValue(Promise.resolve('token'));
-      mockClient.on.and.callFake((event: string, callback: Function): any => {
-        if (event === 'ready') {
-          setTimeout(() => callback(), 10);
-        }
-      });
-
-      const result = await provider.start('test-issuer');
-
-      expect(mockClient.login).toHaveBeenCalledWith(config.token);
-    });
-
-    it('| should throw error if client not initialized', async () => {
-      (provider as any).client = null;
-
-      try {
-        await provider.start('test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        // May be DyFM_Error or Error
-        expect(error).toBeDefined();
-        const errorMessage = (error as DyFM_Error)?._message || (error as Error)?.message || '';
-        expect(errorMessage).toContain('not initialized');
-      }
-    });
-
-    it('| should handle start errors', async () => {
-      const error = new Error('Start failed');
-      mockClient.login.and.returnValue(Promise.reject(error));
-
-      try {
-        await provider.start('test-issuer');
-        fail('Should have thrown an error');
-      } catch (err) {
-        expect(err).toBeInstanceOf(Error);
-      }
-    });
-  });
-
-  describe('| getChannelByName', () => {
-    it('| should return channel from cache if exists', async () => {
-      const cachedChannel = mockTextChannel;
-      (provider as any).channelCache.set('test-channel', cachedChannel);
-
-      const result = await provider.getChannelByName('test-channel');
-
-      expect(result).toBeDefined();
-      expect(result.name).toBe('test-channel');
-    });
-
-    it('| should find channel in guild and cache it', async () => {
-      (provider as any).channelCache.clear();
-
-      const result = await provider.getChannelByName('test-channel');
-
-      expect(result).toBeDefined();
-      expect((provider as any).channelCache.has('test-channel')).toBe(true);
-    });
-
-    it('| should throw error if channel not found', async () => {
-      Object.defineProperty(mockGuild.channels, 'cache', { value: new Collection(), writable: true });
-      (mockGuild.channels as any).find = jasmine.createSpy('find').and.returnValue(null);
-
-      try {
-        await provider.getChannelByName('non-existent');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toContain('No text channel found');
-      }
-    });
-  });
-
-  describe('| getChannelById', () => {
-    it('| should return channel by id', async () => {
-      const result = await provider.getChannelById('channel-123');
-
-      expect(result).toBeDefined();
-      expect(result.id).toBe('channel-123');
-    });
-
-    it('| should throw error if channel not found', async () => {
-      Object.defineProperty(mockGuild.channels, 'cache', { value: new Collection(), writable: true });
-      (mockGuild.channels as any).get = jasmine.createSpy('get').and.returnValue(null);
-
-      try {
-        await provider.getChannelById('non-existent');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toContain('No text channel found');
-      }
-    });
-  });
-
-  describe('| sendMessageToChannel', () => {
-    it('| should send message to channel', async () => {
-      const channelWrapper = await provider.getChannelByName('test-channel');
-      mockTextChannel.send.and.returnValue(Promise.resolve(mockMessage as any));
-
-      const result = await provider.sendMessageToChannel(channelWrapper, 'Test message');
-
-      expect(mockTextChannel.send).toHaveBeenCalledWith('Test message');
-      expect(result).toBeDefined();
-    });
-
-    it('| should split long messages', async () => {
-      const longMessage = 'x'.repeat(5000);
-      const channelWrapper = await provider.getChannelByName('test-channel');
-      mockTextChannel.send.and.returnValue(Promise.resolve(mockMessage as any));
-
-      const result = await provider.sendMessageToChannel(channelWrapper, longMessage);
-
-      // Message split depends on implementation - expect at least 2 calls for long message
-      expect(mockTextChannel.send).toHaveBeenCalled();
-      expect(mockTextChannel.send.calls.count()).toBeGreaterThanOrEqual(2);
-      expect(result).toBeDefined();
-    });
-
-    // Skip - wrapChannel calls isDMBased which doesn't exist on mocked channel
-    it('| should throw error if channel is not text-based', async () => {
-      // Skipped - mock channel doesn't have isDMBased method
-    });
-  });
-
-  describe('| replyToMessage', () => {
-    it('| should reply to message', async () => {
-      const messageWrapper = await provider.wrapMessage(mockMessage);
-      mockMessage.reply.and.returnValue(Promise.resolve(mockMessage as any));
-
-      const result = await provider.replyToMessage(messageWrapper, 'Reply');
-
-      expect(mockMessage.reply).toHaveBeenCalledWith('Reply');
-      expect(result).toBeDefined();
-    });
-
-    it('| should handle reply errors', async () => {
-      const messageWrapper = await provider.wrapMessage(mockMessage);
-      const error = new Error('Reply failed');
-      mockMessage.reply.and.returnValue(Promise.reject(error));
-
-      try {
-        await provider.replyToMessage(messageWrapper, 'Reply');
-        fail('Should have thrown an error');
-      } catch (err) {
-        expect(err).toBeInstanceOf(DyFM_Error);
-      }
-    });
-  });
-
-  describe('| getUserByName', () => {
-    it('| should return user by username', async () => {
-      const result = await provider.getUserByName('test-user');
-
-      expect(result).toBeDefined();
-      expect(result.username).toBe('test-user');
-    });
-
-    it('| should throw error if user not found', async () => {
-      Object.defineProperty(mockGuild.members, 'cache', { value: new Collection(), writable: true });
-      (mockGuild.members as any).find = jasmine.createSpy('find').and.returnValue(null);
-
-      try {
-        await provider.getUserByName('non-existent');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toContain('User not found');
-      }
-    });
-  });
-
-  describe('| getUserMention', () => {
-    it('| should return user mention', () => {
-      const mention = provider.getUserMention('user-123');
-
-      expect(mention).toBe('<@user-123>');
-    });
-  });
-
-  describe('| getRoleByName', () => {
-    it('| should return role from cache if exists', () => {
-      (provider as any).roleCache.set('Test Role', mockRole);
-
-      const result = provider.getRoleByName('Test Role');
-
-      expect(result).toBe(mockRole);
-    });
-
-    it('| should find role in guild and cache it', () => {
-      (provider as any).roleCache.clear();
-
-      const result = provider.getRoleByName('Test Role');
-
-      expect(result).toBe(mockRole);
-      expect((provider as any).roleCache.has('Test Role')).toBe(true);
-    });
-  });
-
-  describe('| getRolePingByName', () => {
-    it('| should return role ping', async () => {
-      const result = await provider.getRolePingByName('Test Role');
-
-      expect(result).toBe('<@&role-123>');
-    });
-
-    it('| should return empty string if role not found', async () => {
-      Object.defineProperty(mockGuild.roles, 'cache', { value: new Collection(), writable: true });
-      (mockGuild.roles as any).find = jasmine.createSpy('find').and.returnValue(null);
-
-      const result = await provider.getRolePingByName('Non-existent');
-
-      expect(result).toBe('');
-    });
-  });
-
-  describe('| getRolePingsByName', () => {
-    it('| should return multiple role pings', async () => {
-      const result = await provider.getRolePingsByName(['Test Role', 'Another Role']);
-
-      expect(result).toContain('<@&role-123>');
-    });
-  });
-
-  describe('| wrapMessage', () => {
-    it('| should wrap Discord message correctly', async () => {
-      const wrapped = await provider.wrapMessage(mockMessage);
-
-      expect(wrapped.id).toBe('message-123');
-      expect(wrapped.content).toBe('Test message');
-      expect(wrapped.authorId).toBe('user-123');
-      expect(wrapped.authorName).toBe('test-user');
-    });
-  });
-
-  describe('| wrapChannel', () => {
-    it('| should wrap Discord channel correctly', async () => {
-      const wrapped = await provider.wrapChannel(mockTextChannel);
-
-      expect(wrapped.id).toBe('channel-123');
-      expect(wrapped.name).toBe('test-channel');
-      expect(wrapped.isTextBased).toBe(true);
-    });
-  });
-
-  describe('| wrapUser', () => {
-    it('| should wrap Discord user correctly', async () => {
-      const wrapped = await provider.wrapUser(mockGuildMember);
-
-      expect(wrapped.id).toBe('user-123');
-      expect(wrapped.username).toBe('test-user');
-      expect(wrapped.displayName).toBe('Test User');
-    });
-  });
-
-  describe('| sendReport', () => {
-    it('| should send report to report channel', async () => {
-      spyOn(provider, 'sendMessageToChannelByName').and.returnValue(provider.wrapMessage(mockMessage));
-
-      const result = await provider.sendReport('Test report');
-
-      expect(provider.sendMessageToChannelByName).toHaveBeenCalledWith('reports', 'Test report');
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('| create_onMessageEventListener', () => {
-    it('| should create message event listener', () => {
-      const handler = jasmine.createSpy('handler');
-
-      provider.create_onMessageEventListener(handler);
-
-      expect(mockClient.on).toHaveBeenCalledWith('messageCreate', jasmine.any(Function));
-    });
-  });
-
-  describe('| create_onErrorEventListener', () => {
-    it('| should create error event listener', () => {
-      const handler = jasmine.createSpy('handler');
-
-      provider.create_onErrorEventListener(handler);
-
-      expect(mockClient.on).toHaveBeenCalledWith('error', jasmine.any(Function));
-    });
-  });
-});
-