@messenger-box/platform-server 10.0.3-alpha.50 → 10.0.3-alpha.54

package/lib/services/channel-service.d.ts

@@ -1,44 +1,196 @@
-import { IChannel, IChannelUnread, IPost, IUserAccount, IChannelRepository, IChannelService, IPostService, ISaveChannelParams, ISaveDirectChannelParams, ISavePublicChannelParams, INotificationProps, ICreateDirectChannelParams, ISaveMembersToChannelParams } from 'common/server';
-import { BaseService } from '@common-stack/store-mongo';
-export declare class ChannelService extends BaseService<IChannel, Omit<IChannel, 'id'>> implements IChannelService {
+import { Disposable, DisposableCollection, Emitter } from '@adminide-stack/core';
+import { IChannelModel, IChannelUnread, IPost, IUserAccount, IChannelRepository, IChannelService, IPostService, ISaveChannelParams, ISaveDirectChannelParams, ISavePublicChannelParams, INotificationProps, ICreateDirectChannelParams, ISaveMembersToChannelParams, AsDomainType, IRedisCacheManager, IUserContext } from 'common/server';
+import { BaseService2 } from '@common-stack/store-mongo';
+import { CdmLogger } from '@cdm-logger/core';
+import { ServiceBroker } from 'moleculer';
+import type { Redis } from 'ioredis';
+/**
+ * Modern implementation of the Channel Service
+ *
+ * This service handles comprehensive channel management within the messenger platform,
+ * providing operations for managing channels, their members, and related messaging workflows.
+ *
+ * Key capabilities:
+ * - Channel lifecycle management (creation, updates, deletion)
+ * - Member management (adding, removing, role assignment)
+ * - Direct and public channel handling
+ * - Message and post management within channels
+ * - Channel visibility and access control
+ * - Notification and unread message tracking
+ * - Team-based channel organization
+ * - Channel discovery and filtering
+ * - Redis caching for performance optimization
+ * - Comprehensive error handling and logging
+ * - Event-driven architecture with proper disposal
+ *
+ * The service layer abstracts the underlying data access operations and
+ * provides a cohesive API for channel-related functionality throughout
+ * the messaging platform, handling complex business rules and cross-cutting concerns.
+ */
+export declare class ChannelService extends BaseService2<IChannelModel> implements IChannelService, Disposable {
     readonly repository: IChannelRepository;
     private readonly postService;
-    constructor(repository: IChannelRepository, postService: IPostService);
+    protected readonly broker?: ServiceBroker;
+    protected readonly redisCacheManager?: IRedisCacheManager;
+    protected readonly redisClient?: Redis;
+    protected readonly onChannelCreated: Emitter<{
+        channel: AsDomainType<IChannelModel>;
+        userContext?: IUserContext;
+    }>;
+    protected readonly onChannelUpdated: Emitter<{
+        channel: AsDomainType<IChannelModel>;
+        oldChannel: AsDomainType<IChannelModel>;
+        userContext?: IUserContext;
+    }>;
+    protected readonly onChannelDeleted: Emitter<{
+        channelId: string;
+        channelName?: string;
+        userContext?: IUserContext;
+    }>;
+    protected readonly onChannelRestored: Emitter<{
+        channel: AsDomainType<IChannelModel>;
+        userContext?: IUserContext;
+    }>;
+    protected readonly onMemberAdded: Emitter<{
+        channelId: string;
+        memberId: string;
+        userContext?: IUserContext;
+    }>;
+    protected readonly onMemberRemoved: Emitter<{
+        channelId: string;
+        memberId: string;
+        userContext?: IUserContext;
+    }>;
+    protected readonly onChannelViewed: Emitter<{
+        channelId: string;
+        userId: string;
+        timestamp: Date;
+    }>;
+    protected readonly toDispose: DisposableCollection;
+    private logger;
+    constructor(repository: IChannelRepository, postService: IPostService, broker?: ServiceBroker, redisCacheManager?: IRedisCacheManager, redisClient?: Redis, logger?: CdmLogger.ILogger);
+    /**
+     * Disposes of resources used by the service
+     */
+    dispose(): void;
+    /**
+     * Helper method to make service calls
+     * @param command - Command to execute
+     * @param params - Command parameters
+     * @param topic - Service topic
+     * @param opts - Call options
+     * @returns Command result
+     */
+    private callAction;
+    /**
+     * Invalidates channel cache entries
+     * @param channelId - Channel ID
+     * @param channelName - Channel name
+     */
+    private invalidateChannelCache;
+    /**
+     * Enhanced method to check if a user is a member of a specific channel
+     *
+     * @description Verifies channel membership with proper error handling and logging
+     *
+     * @param {string} channelId - The ID of the channel to check
+     * @param {string} user - The ID of the user
+     * @returns {Promise<boolean>} - True if the user is a member
+     */
     isMember(channelId: string, user: string): Promise<boolean>;
-    private static getDmNameFromIds;
+    /**
+     * Enhanced method to get default notification properties
+     *
+     * @description Retrieves default notification settings with extensibility
+     *
+     * @returns {INotificationProps} - Default notification properties
+     */
     get defaultNotifyProps(): INotificationProps;
+    /**
+     * Enhanced method to get maximum channels per team with configuration support
+     *
+     * @description Retrieves channel limit with future configuration support
+     *
+     * @param {string} teamId - The ID of the team
+     * @returns {Promise<number>} - Maximum number of channels allowed
+     */
     private static getMaxChannelsPerTeam;
+    /**
+     * Enhanced method to get current channel count per team
+     *
+     * @description Counts active channels for a team with proper error handling
+     *
+     * @param {string} team - The team identifier
+     * @returns {Promise<number>} - Current channel count
+     */
     private getCurrentChannelCountPerTeam;
-    createDirectChannel(data: ICreateDirectChannelParams): Promise<IChannel>;
-    saveDirectChannel(channel: ISaveDirectChannelParams): Promise<IChannel>;
-    addMemberToChannel(channelId: any, memberId: any): Promise<IChannel>;
-    saveMembersToChannel(data: ISaveMembersToChannelParams): Promise<any>;
-    saveChannel(data: ISaveChannelParams): Promise<IChannel>;
-    savePublicChannel(data: ISavePublicChannelParams): Promise<IChannel>;
-    getChannelUnread(channelId: string, userId: string): Promise<IChannelUnread>;
-    getPinnedPosts(channelId: string): Promise<IPost[]>;
-    restore(channelId: string, time: Date): Promise<IChannel>;
-    getByName(title: string): Promise<IChannel>;
-    getByNameIncludeDeleted(team: string, title: string): Promise<IChannel>;
-    getByNames(team: string, titles: string[]): Promise<IChannel[]>;
-    getChannelCounts(team: string, user: string): Promise<any>;
-    getChannels(team: string, user: string, includeDeleted: boolean, lastDeleteAt: number, orgName: string): Promise<IChannel[]>;
+    /**
+     * Enhanced method to generate DM name from user IDs
+     *
+     * @description Creates a standardized direct message channel name
+     *
+     * @param {string} senderId - The sender's user ID
+     * @param {string} receiverId - The receiver's user ID
+     * @returns {string} - Generated DM name
+     */
+    private static getDmNameFromIds;
+    /**
+     * Enhanced method to create a direct channel between users
+     *
+     * @description Creates direct channels with comprehensive validation and error handling
+     *
+     * @param {ICreateDirectChannelParams} data - The direct channel creation parameters
+     * @returns {Promise<AsDomainType<IChannelModel> | Error>} - The created channel or error
+     */
+    createDirectChannel(data: ICreateDirectChannelParams): Promise<AsDomainType<IChannelModel> | Error>;
+    /**
+     * Enhanced method to save a direct channel
+     *
+     * @description Saves direct channels with comprehensive validation
+     *
+     * @param {ISaveDirectChannelParams} channel - The direct channel parameters
+     * @returns {Promise<AsDomainType<IChannelModel> | Error>} - The created channel or error
+     */
+    saveDirectChannel(channel: ISaveDirectChannelParams): Promise<AsDomainType<IChannelModel> | Error>;
+    /**
+     * Enhanced method to add a member to a channel
+     *
+     * @description Adds a single member to a channel with comprehensive validation and event firing
+     *
+     * @param {string} channelId - The ID of the channel
+     * @param {string} memberId - The ID of the member to add
+     * @returns {Promise<AsDomainType<IChannelModel> | Error>} - The updated channel or error
+     */
+    addMemberToChannel(channelId: string, memberId: string): Promise<AsDomainType<IChannelModel> | Error>;
+    saveMembersToChannel(data: ISaveMembersToChannelParams): Promise<AsDomainType<IChannelModel> | Error>;
+    saveChannel(data: ISaveChannelParams): Promise<AsDomainType<IChannelModel> | Error>;
+    savePublicChannel(data: ISavePublicChannelParams): Promise<AsDomainType<IChannelModel> | Error>;
+    getChannelUnread(channelId: string, userId: string): Promise<IChannelUnread | Error>;
+    getPinnedPosts(channelId: string): Promise<IPost[] | Error>;
+    getFromMaster(id: string): Promise<AsDomainType<IChannelModel> | Error>;
+    restore(channelId: string, time: Date): Promise<void>;
+    getByName(title: string): Promise<IChannelModel>;
+    getByNameIncludeDeleted(teamId: string, name: string): Promise<AsDomainType<IChannelModel> | Error>;
+    getByNames(teamId: string, names: string[]): Promise<Array<AsDomainType<IChannelModel>> | Error>;
+    getChannelCounts(teamId: string, userId: string): Promise<any | Error>;
+    getChannels(teamId: string, userId: string, includeDeleted: boolean, lastDeleteAt: number, orgId: string): Promise<Array<AsDomainType<IChannelModel>> | Error>;
     private generateCriteria;
-    deleteChannel(id: string): Promise<boolean>;
-    getDeleted(teamId: string, offset: number, limit: number, userId: string): Promise<IChannel[]>;
-    getDeletedByName(teamId: string, name: string): Promise<IChannel>;
-    getFromMaster(id: string): Promise<IChannel>;
-    getMoreChannels(teamId: string, userId: string, offset: number, limit: number): Promise<IChannel[]>;
-    getPrivateChannelsForTeam(teamId: string, offset: number, limit: number): Promise<IChannel[]>;
-    getPublicChannelsByIdsForTeam(teamId: string, channelsIds: string[]): Promise<IChannel[]>;
-    getPublicChannelsForTeam(teamId: string, offset: number, limit: number): Promise<IChannel[]>;
-    getTeamChannels(teamId: string): Promise<IChannel[]>;
+    deleteChannel(id: string): Promise<boolean | Error>;
+    getDeleted(teamId: string, offset: number, limit: number, userId: string): Promise<Array<AsDomainType<IChannelModel>> | Error>;
+    getDeletedByName(teamId: string, name: string): Promise<AsDomainType<IChannelModel> | Error>;
+    getMoreChannels(teamId: string, userId: string, offset: number, limit: number): Promise<Array<AsDomainType<IChannelModel>> | Error>;
+    getPrivateChannelsForTeam(teamId: string, offset: number, limit: number): Promise<Array<AsDomainType<IChannelModel>> | Error>;
+    getPublicChannelsByIdsForTeam(teamId: string, channelsIds: string[]): Promise<Array<AsDomainType<IChannelModel>> | Error>;
+    getPublicChannelsForTeam(teamId: string, offset: number, limit: number): Promise<Array<AsDomainType<IChannelModel>> | Error>;
+    getTeamChannels(teamId: string): Promise<Array<AsDomainType<IChannelModel>> | Error>;
     hideChannel(id: string): Promise<boolean>;
-    invalidateChannelByName(teamId: string, name: string): Promise<void>;
     leaveChannel(id: string): Promise<boolean>;
     viewChannel(id: string, user: string): Promise<boolean>;
-    permanentDelete(channelId: string): void;
-    permanentDeleteByTeam(teamId: string): void;
-    permanentDeleteMembersByChannel(channelId: string): void;
-    saveMultipleMembers(members: IUserAccount[]): Promise<IUserAccount[]>;
+    permanentDelete(channelId: string): Promise<void | Error>;
+    permanentDeleteByTeam(teamId: string): Promise<void | Error>;
+    permanentDeleteMembersByChannel(channelId: string): Promise<void | Error>;
+    saveMultipleMembers(members: IUserAccount[]): Promise<IUserAccount[] | Error>;
+    invalidateChannelByName(teamId: string, name: string): Promise<void>;
 }
+declare const _default: any;
+export default _default;