@futdevpro/nts-dynamo 1.15.157 → 1.15.160

package/src/_modules/bot/_modules/dynamo-bot/_collections/dyb-operations.util.spec.ts

@@ -1,160 +0,0 @@
-
-import { DyNTS_DyB_Operations_Util } from './dyb-operations.util';
-import { DyNTS_DyB_MessagingProvider_ControlService } from '../_services/dyb-messaging-provider.control-service';
-import { DyNTS_DyB_Message, DyNTS_DyB_Channel } from '../_models/dyb-platform.types';
-
-describe('| DyNTS_DyB_Operations_Util', () => {
-  describe('| getConversationStats', () => {
-    it('| should return conversation statistics', async () => {
-      const mockProvider = {
-        fetchMessagesById: jasmine.createSpy('fetchMessagesById').and.returnValue(
-          Promise.resolve([
-            { id: 'msg-1', content: 'Message 1', timestamp: new Date('2024-01-01T12:00:00Z').getTime() },
-            { id: 'msg-2', content: 'Message 2', timestamp: new Date('2024-01-01T13:00:00Z').getTime() },
-          ] as DyNTS_DyB_Message[])
-        ),
-        getChannelById: jasmine.createSpy('getChannelById').and.returnValue(
-          Promise.resolve({
-            id: 'channel-123',
-            participants: [
-              { id: 'user-1' },
-              { id: 'user-2' },
-            ],
-          } as unknown as DyNTS_DyB_Channel)
-        ),
-      } as any;
-
-      const result = await DyNTS_DyB_Operations_Util.getConversationStats(
-        mockProvider,
-        'conv-123'
-      );
-
-      expect(result.messageCount).toBe(2);
-      expect(result.participantCount).toBe(2);
-      expect(result.lastActivity).toBeInstanceOf(Date);
-      expect(mockProvider.fetchMessagesById).toHaveBeenCalledWith('conv-123', 1000);
-      expect(mockProvider.getChannelById).toHaveBeenCalledWith('conv-123');
-    });
-
-    it('| should return null lastActivity when no messages', async () => {
-      const mockProvider = {
-        fetchMessagesById: jasmine.createSpy('fetchMessagesById').and.returnValue(
-          Promise.resolve([])
-        ),
-        getChannelById: jasmine.createSpy('getChannelById').and.returnValue(
-          Promise.resolve({
-            id: 'channel-123',
-            participants: [],
-          } as unknown as DyNTS_DyB_Channel)
-        ),
-      } as any;
-
-      const result = await DyNTS_DyB_Operations_Util.getConversationStats(
-        mockProvider,
-        'conv-123'
-      );
-
-      expect(result.messageCount).toBe(0);
-      expect(result.participantCount).toBe(0);
-      expect(result.lastActivity).toBeNull();
-    });
-
-    it('| should handle errors gracefully', async () => {
-      const mockProvider = {
-        fetchMessagesById: jasmine.createSpy('fetchMessagesById').and.returnValue(
-          Promise.reject(new Error('Failed to fetch'))
-        ),
-        getChannelById: jasmine.createSpy('getChannelById').and.returnValue(
-          Promise.resolve({} as unknown as DyNTS_DyB_Channel)
-        ),
-      } as any;
-
-      const result = await DyNTS_DyB_Operations_Util.getConversationStats(
-        mockProvider,
-        'conv-123'
-      );
-
-      expect(result.messageCount).toBe(0);
-      expect(result.participantCount).toBe(0);
-      expect(result.lastActivity).toBeNull();
-    });
-  });
-
-  describe('| searchMessages', () => {
-    it('| should search messages by content', async () => {
-      const mockProvider = {
-        fetchMessagesById: jasmine.createSpy('fetchMessagesById').and.returnValue(
-          Promise.resolve([
-            { id: 'msg-1', content: 'Hello world', timestamp: Date.now() },
-            { id: 'msg-2', content: 'Goodbye world', timestamp: Date.now() },
-            { id: 'msg-3', content: 'Hello there', timestamp: Date.now() },
-          ] as DyNTS_DyB_Message[])
-        ),
-      } as any;
-
-      const result = await DyNTS_DyB_Operations_Util.searchMessages(
-        mockProvider,
-        'conv-123',
-        'Hello'
-      );
-
-      expect(result.length).toBe(2);
-      expect(result[0].content).toBe('Hello world');
-      expect(result[1].content).toBe('Hello there');
-    });
-
-    it('| should be case insensitive', async () => {
-      const mockProvider = {
-        fetchMessagesById: jasmine.createSpy('fetchMessagesById').and.returnValue(
-          Promise.resolve([
-            { id: 'msg-1', content: 'Hello world', timestamp: Date.now() },
-            { id: 'msg-2', content: 'HELLO WORLD', timestamp: Date.now() },
-          ] as DyNTS_DyB_Message[])
-        ),
-      } as any;
-
-      const result = await DyNTS_DyB_Operations_Util.searchMessages(
-        mockProvider,
-        'conv-123',
-        'hello'
-      );
-
-      expect(result.length).toBe(2);
-    });
-
-    it('| should return empty array when no matches', async () => {
-      const mockProvider = {
-        fetchMessagesById: jasmine.createSpy('fetchMessagesById').and.returnValue(
-          Promise.resolve([
-            { id: 'msg-1', content: 'Hello world', timestamp: Date.now() },
-          ] as DyNTS_DyB_Message[])
-        ),
-      } as any;
-
-      const result = await DyNTS_DyB_Operations_Util.searchMessages(
-        mockProvider,
-        'conv-123',
-        'Goodbye'
-      );
-
-      expect(result).toEqual([]);
-    });
-
-    it('| should handle errors gracefully', async () => {
-      const mockProvider = {
-        fetchMessagesById: jasmine.createSpy('fetchMessagesById').and.returnValue(
-          Promise.reject(new Error('Failed to fetch'))
-        ),
-      } as any;
-
-      const result = await DyNTS_DyB_Operations_Util.searchMessages(
-        mockProvider,
-        'conv-123',
-        'search'
-      );
-
-      expect(result).toEqual([]);
-    });
-  });
-});
-

package/src/_modules/bot/_modules/dynamo-bot/_collections/dyb-operations.util.ts

@@ -1,55 +0,0 @@
-import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
-import { DyNTS_DyB_MessagingProvider_ControlService } from '../_services/dyb-messaging-provider.control-service';
-import { DyNTS_DyB_Message, DyNTS_DyB_Channel } from '../_models/dyb-platform.types';
-
-export class DyNTS_DyB_Operations_Util {
-
-  /**
-   * Get conversation statistics
-   */
-  static async getConversationStats(
-    provider: DyNTS_DyB_MessagingProvider_ControlService, 
-    conversationId: string
-  ): Promise<{
-    messageCount: number;
-    participantCount: number;
-    lastActivity: Date | null;
-  }> {
-    try {
-      const messages: DyNTS_DyB_Message[] = await provider.fetchMessagesById(conversationId, 1000);
-      const channel: DyNTS_DyB_Channel = await provider.getChannelById(conversationId);
-      
-      return {
-        messageCount: messages.length,
-        participantCount: channel.participants?.length || 0,
-        lastActivity: messages.length > 0 ? new Date(messages[0].timestamp) : null
-      };
-    } catch (error) {
-      DyFM_Error.logSimple('Failed to get conversation stats', error);
-      return {
-        messageCount: 0,
-        participantCount: 0,
-        lastActivity: null
-      };
-    }
-  }
-
-  /**
-   * Search messages in conversation
-   */
-  static async searchMessages(
-    provider: DyNTS_DyB_MessagingProvider_ControlService, 
-    conversationId: string, 
-    searchTerm: string
-  ): Promise<DyNTS_DyB_Message[]> {
-    try {
-      const messages: DyNTS_DyB_Message[] = await provider.fetchMessagesById(conversationId, 1000);
-      return messages.filter((msg: DyNTS_DyB_Message) => 
-        msg.content.toLowerCase().includes(searchTerm.toLowerCase())
-      );
-    } catch (error) {
-      DyFM_Error.logSimple('Failed to search messages', error);
-      return [];
-    }
-  }
-}

package/src/_modules/bot/_modules/dynamo-bot/_models/dyb-platform.types.ts

@@ -1,15 +0,0 @@
-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';
-import { DyFM_Msg_Message, DyFM_Msg_Conversation, DyFM_Msg_Participant } from '@futdevpro/fsm-dynamo/messaging';
-
-// Dynamo Bot Platform-Specific Types
-// Uses messaging system models as the underlying platform
-export type DyNTS_DyB_Message = DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>;
-
-// Extended channel interface for dynamo bot with participants
-export interface DyNTS_DyB_Channel extends DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> {
-  participants?: DyFM_Msg_Participant[];
-}
-
-export type DyNTS_DyB_User = DyNTS_Bot_UserWrapper<any>; // Messaging system user (generic)

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

@@ -1,374 +0,0 @@
-
-import { DyNTS_DyB_MessagingProvider_ControlService, Dynamo_MessagingProviderConfig } from './dyb-messaging-provider.control-service';
-import { DyFM_Msg_Provider_Type, DyFM_Msg_Conversation, DyFM_Msg_Message, DyFM_Msg_Participant, DyFM_Msg_ConversationType } from '@futdevpro/fsm-dynamo/messaging';
-import { DyNTS_Msg_Main_ControlService } from '../../../../messaging/_services/msg-main.control-service';
-import { DyNTS_Msg_Message_DataService } from '../../../../messaging/_services/msg-message.data-service';
-import { DyNTS_Msg_Conversation_DataService } from '../../../../messaging/_services/msg-conversation.data-service';
-import { DyNTS_Msg_Events_Service } from '../../../../messaging/_services/msg-events.service';
-import { DyFM_Error, DyFM_Log, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
-import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
-
-// Skipped: DyFM_Error stack trace causes Jasmine 'split' errors
-describe('| DyNTS_DyB_MessagingProvider_ControlService', () => {
-  // Initialize global settings before tests
-  beforeAll(() => {
-    if (!DyNTS_global_settings.systemShortCodeName) {
-      (DyNTS_global_settings as any).systemShortCodeName = 'TEST';
-    }
-    if (!DyNTS_global_settings.env_settings) {
-      (DyNTS_global_settings as any).env_settings = {
-        environment: DyFM_EnvironmentFlag.local,
-      };
-    }
-  });
-  let provider: DyNTS_DyB_MessagingProvider_ControlService;
-  let mockMessaging_CS: jasmine.SpyObj<DyNTS_Msg_Main_ControlService>;
-  let mockEventsService: jasmine.SpyObj<DyNTS_Msg_Events_Service>;
-  let mockMessageDataService: jasmine.SpyObj<DyNTS_Msg_Message_DataService>;
-  let mockConversationDataService: jasmine.SpyObj<DyNTS_Msg_Conversation_DataService>;
-
-  const config: Dynamo_MessagingProviderConfig = {
-    reportChannelName: 'reports',
-    botUserId: 'bot-123',
-    botDisplayName: 'Dynamo Bot',
-  };
-
-  beforeEach(() => {
-    mockMessaging_CS = jasmine.createSpyObj('DyNTS_Msg_Main_ControlService', ['sendMessage', 'deleteMessage'], {
-      getInstance: jasmine.createSpy('getInstance').and.returnValue(mockMessaging_CS),
-    });
-
-    mockEventsService = jasmine.createSpyObj('DyNTS_Msg_Events_Service', [], {
-      getInstance: jasmine.createSpy('getInstance').and.returnValue(mockEventsService),
-    });
-
-    const mockMessageDBService = {
-      find: jasmine.createSpy('find').and.returnValue(Promise.resolve([])),
-      findOne: jasmine.createSpy('findOne').and.returnValue(Promise.resolve(null)),
-    };
-    mockMessageDataService = jasmine.createSpyObj('DyNTS_Msg_Message_DataService', [], {
-      dataDBService: mockMessageDBService,
-    });
-
-    const mockConversationDBService = {
-      findOne: jasmine.createSpy('findOne').and.returnValue(Promise.resolve(null)),
-    };
-    mockConversationDataService = jasmine.createSpyObj('DyNTS_Msg_Conversation_DataService', [], {
-      dataDBService: mockConversationDBService,
-    });
-
-    spyOn(DyNTS_Msg_Main_ControlService, 'getInstance').and.returnValue(mockMessaging_CS);
-    spyOn(DyNTS_Msg_Events_Service, 'getInstance').and.returnValue(mockEventsService);
-    spyOn(DyNTS_Msg_Message_DataService.prototype, 'constructor' as any).and.returnValue(mockMessageDataService);
-    spyOn(DyNTS_Msg_Conversation_DataService.prototype, 'constructor' as any).and.returnValue(mockConversationDataService);
-
-    provider = new DyNTS_DyB_MessagingProvider_ControlService(config);
-  });
-
-  describe('| constructor', () => {
-    it('| should initialize with config', () => {
-      expect(provider.config).toEqual(config);
-      expect(provider.name).toBe('dynamo');
-      expect(provider.type).toBe(DyFM_Msg_Provider_Type.dynamo);
-    });
-  });
-
-  describe('| properties', () => {
-    it('| should return botId from config', () => {
-      expect(provider.botId).toBe('bot-123');
-    });
-
-    it('| should return default botId if not in config', () => {
-      const providerWithoutBotId = new DyNTS_DyB_MessagingProvider_ControlService({
-        reportChannelName: 'reports',
-      });
-
-      expect(providerWithoutBotId.botId).toBe('dynamo-bot');
-    });
-
-    it('| should return botDisplayName from config', () => {
-      expect(provider.botDisplayName).toBe('Dynamo Bot');
-    });
-
-    it('| should return default botDisplayName if not in config', () => {
-      const providerWithoutDisplayName = new DyNTS_DyB_MessagingProvider_ControlService({
-        reportChannelName: 'reports',
-      });
-
-      expect(providerWithoutDisplayName.botDisplayName).toBe('Dynamo Bot');
-    });
-  });
-
-  describe('| setup', () => {
-    it('| should setup provider successfully', async () => {
-      const logSpy = spyOn(DyFM_Log, 'success');
-
-      await provider.setup('test-issuer');
-
-      expect(logSpy).toHaveBeenCalledWith('Dynamo bot provider setup completed');
-    });
-
-    it('| should handle setup errors', async () => {
-      const error = new Error('Setup failed');
-      // Mock setupEventListeners to throw an error
-      spyOn(provider as any, 'setupEventListeners').and.throwError(error);
-
-      try {
-        await provider.setup('test-issuer');
-        // Setup doesn't call setupEventListeners, so it won't throw
-        // The test should verify that setup completes successfully
-        expect(true).toBe(true);
-      } catch (err) {
-        // If an error is thrown, it should be a DyFM_Error
-        expect(err).toBeInstanceOf(DyFM_Error);
-        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-DyB-MessagingProvider-S000');
-      }
-    });
-  });
-
-  describe('| start', () => {
-    it('| should start provider successfully', async () => {
-      const logSpy = spyOn(DyFM_Log, 'success');
-
-      await provider.start('test-issuer');
-
-      expect(logSpy).toHaveBeenCalledWith('Dynamo bot provider started');
-    });
-
-    it('| should handle start errors', async () => {
-      const error = new Error('Start failed');
-      // Mock setupEventListeners to throw an error
-      spyOn(provider as any, 'setupEventListeners').and.throwError(error);
-
-      try {
-        await provider.start('test-issuer');
-        fail('Should have thrown an error');
-      } catch (err) {
-        expect(err).toBeInstanceOf(DyFM_Error);
-        expect((err as DyFM_Error)._errorCode).toContain('DyNTS-DyB-MessagingProvider-S001');
-      }
-    });
-  });
-
-  describe('| getChannelByName', () => {
-    it('| should return channel from cache if exists', async () => {
-      const mockConversation: DyFM_Msg_Conversation = {
-        _id: 'conv-123',
-        name: 'test-channel',
-        title: 'test-channel',
-        type: DyFM_Msg_ConversationType.group,
-        participants: [],
-      } as DyFM_Msg_Conversation;
-
-      ((provider as any).channelCache as Map<string, DyFM_Msg_Conversation>).set('test-channel', mockConversation);
-
-      const result = await provider.getChannelByName('test-channel');
-
-      expect(result).toBeDefined();
-      expect(result.name).toBe('test-channel');
-    });
-  });
-
-  describe('| sendMessageToChannel', () => {
-    it('| should send message through messaging service', async () => {
-      const mockChannel = await provider.wrapChannel({
-        _id: 'conv-123',
-        name: 'test-channel',
-        title: 'test-channel',
-        type: DyFM_Msg_ConversationType.group,
-        participants: [],
-      } as DyFM_Msg_Conversation);
-
-      const mockMessage: DyFM_Msg_Message = {
-        _id: 'msg-123',
-        content: 'Test message',
-        conversationId: 'conv-123',
-        senderId: 'bot-123',
-        mentions: [],
-      } as DyFM_Msg_Message;
-
-      mockMessaging_CS.sendMessage.and.returnValue(Promise.resolve(mockMessage));
-
-      const result = await provider.sendMessageToChannel(mockChannel, 'Test message', 'test-issuer');
-
-      expect(mockMessaging_CS.sendMessage).toHaveBeenCalledWith('conv-123', { content: 'Test message' }, 'bot-123', 'test-issuer');
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('| sendMessageToChannelByName', () => {
-    it('| should get channel and send message', async () => {
-      spyOn(provider, 'getChannelByName').and.returnValue(
-        provider.wrapChannel({
-          _id: 'conv-123',
-          name: 'test-channel',
-          title: 'test-channel',
-          type: DyFM_Msg_ConversationType.group,
-          participants: [],
-        } as DyFM_Msg_Conversation)
-      );
-      spyOn(provider, 'sendMessageToChannel').and.returnValue(
-        provider.wrapMessage({
-          _id: 'msg-123',
-          content: 'Test message',
-          mentions: [],
-        } as DyFM_Msg_Message)
-      );
-
-      const result = await provider.sendMessageToChannelByName('test-channel', 'Test message', 'test-issuer');
-
-      expect(provider.getChannelByName).toHaveBeenCalledWith('test-channel');
-      expect(provider.sendMessageToChannel).toHaveBeenCalled();
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('| deleteMessage', () => {
-    it('| should delete message through messaging service', async () => {
-      const mockMessage = await provider.wrapMessage({
-        _id: 'msg-123',
-        content: 'Test message',
-        mentions: [],
-      } as DyFM_Msg_Message);
-
-      mockMessaging_CS.deleteMessage.and.returnValue(Promise.resolve());
-
-      await provider.deleteMessage(mockMessage);
-
-      expect(mockMessaging_CS.deleteMessage).toHaveBeenCalledWith('msg-123', 'dynamo-bot', 'dynamo-bot');
-    });
-  });
-
-  describe('| getUserByName', () => {
-    it('| should return wrapped user', async () => {
-      const result = await provider.getUserByName('test-user');
-
-      expect(result).toBeDefined();
-      expect(result.username).toBe('test-user');
-    });
-  });
-
-  describe('| getUserMention', () => {
-    it('| should return user mention', () => {
-      const mention = provider.getUserMention('user-123');
-
-      expect(mention).toBe('@user-123');
-    });
-  });
-
-  describe('| readMembersInChannel', () => {
-    it('| should return wrapped participants', async () => {
-      const mockChannel = await provider.wrapChannel({
-        _id: 'conv-123',
-        name: 'test-channel',
-        participants: [
-          { userId: 'user-1', username: 'user1' },
-          { userId: 'user-2', username: 'user2' },
-        ],
-      } as any);
-
-      spyOn(provider, 'getChannelByName').and.returnValue(Promise.resolve(mockChannel));
-
-      const result = await provider.readMembersInChannel('test-channel');
-
-      expect(result.length).toBe(2);
-      expect(result[0].username).toBe('user1');
-      expect(result[1].username).toBe('user2');
-    });
-  });
-
-  describe('| wrapMessage', () => {
-    it('| should wrap message correctly', async () => {
-      const mockMessage: DyFM_Msg_Message = {
-        _id: 'msg-123',
-        content: 'Test message',
-        senderId: 'user-123',
-        senderName: 'test-user',
-        conversationId: 'conv-123',
-        sentAt: new Date().toISOString(),
-        mentions: [],
-      } as any;
-
-      const wrapped = await provider.wrapMessage(mockMessage);
-
-      expect(wrapped.id).toBe('msg-123');
-      expect(wrapped.content).toBe('Test message');
-      expect(wrapped.authorId).toBe('user-123');
-      expect(wrapped.authorName).toBe('test-user');
-    });
-  });
-
-  describe('| wrapChannel', () => {
-    it('| should wrap channel correctly', async () => {
-      const mockConversation: DyFM_Msg_Conversation = {
-        _id: 'conv-123',
-        name: 'test-channel',
-        title: 'test-channel',
-        type: DyFM_Msg_ConversationType.group,
-        participants: [],
-      } as DyFM_Msg_Conversation;
-
-      const wrapped = await provider.wrapChannel(mockConversation);
-
-      expect(wrapped.id).toBe('conv-123');
-      expect(wrapped.name).toBe('test-channel');
-      expect(wrapped.isTextBased).toBe(true);
-    });
-  });
-
-  describe('| wrapUser', () => {
-    it('| should wrap user correctly', async () => {
-      const mockUser: any = {
-        userId: 'user-123',
-        username: 'test-user',
-        displayName: 'Test User',
-      };
-
-      const wrapped = await provider.wrapUser(mockUser);
-
-      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({
-          _id: 'msg-123',
-          content: 'Report',
-          mentions: [],
-        } as DyFM_Msg_Message)
-      );
-
-      const result = await provider.sendReport('Test report');
-
-      expect(provider.sendMessageToChannelByName).toHaveBeenCalledWith('reports', 'Test report', 'dynamo-bot');
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('| create_onMessageEventListener', () => {
-    it('| should create message event listener', () => {
-      const handler = jasmine.createSpy('handler');
-      const logSpy = spyOn(DyFM_Log, 'info');
-
-      provider.create_onMessageEventListener(handler);
-
-      expect(logSpy).toHaveBeenCalledWith('Message event listener created (messaging integration)');
-    });
-  });
-
-  describe('| create_onErrorEventListener', () => {
-    it('| should create error event listener', () => {
-      const handler = jasmine.createSpy('handler');
-      const logSpy = spyOn(DyFM_Log, 'info');
-
-      provider.create_onErrorEventListener(handler);
-
-      expect(logSpy).toHaveBeenCalledWith('Error event listener created (messaging integration)');
-    });
-  });
-});
-