@messenger-box/platform-server 10.0.3-alpha.7 → 10.0.3-alpha.74

package/lib/services/channel-service.js

@@ -1,272 +1,720 @@
-import {__decorate,__param,__metadata}from'tslib';import {inject}from'inversify';import {SERVER_TYPES,RoomType,SortEnum}from'common';import {BaseService}from'@common-stack/store-mongo';import'../constants/query.constants.js';import {DEFAULT_NOTIFY_PROPS}from'../constants/default-notify-props.js';var ChannelService_1;
-let ChannelService = ChannelService_1 = class ChannelService extends BaseService {
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import {Emitter,DisposableCollection}from'@adminide-stack/core';import {SERVER_TYPES,RoomType,SortEnum}from'common/server';import {BaseService2}from'@common-stack/store-mongo';import'@cdm-logger/core';import {ServiceBroker}from'moleculer';import {CommonType}from'@common-stack/core';import'../constants/query.constants.js';import {DEFAULT_NOTIFY_PROPS}from'../constants/default-notify-props.js';import {config}from'../config/env-config.js';var ChannelService_1;
+const CACHE_TTL = {
+  maxAge: 5 * 60,
+  scope: 'PUBLIC'
+}; // 5 minutes
+/**
+ * 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.
+ */
+let ChannelService = ChannelService_1 = class ChannelService extends BaseService2 {
   repository;
   postService;
-  constructor(repository, postService) {
+  broker;
+  redisCacheManager;
+  redisClient;
+  inngestClient;
+  // Event emitters for channel lifecycle events
+  onChannelCreated = new Emitter();
+  onChannelUpdated = new Emitter();
+  onChannelDeleted = new Emitter();
+  onChannelRestored = new Emitter();
+  onMemberAdded = new Emitter();
+  onMemberRemoved = new Emitter();
+  onChannelViewed = new Emitter();
+  toDispose = new DisposableCollection(this.onChannelCreated, this.onChannelUpdated, this.onChannelDeleted, this.onChannelRestored, this.onMemberAdded, this.onMemberRemoved, this.onChannelViewed);
+  logger;
+  constructor(repository, postService, broker, redisCacheManager, redisClient, logger, inngestClient) {
     super(repository);
     this.repository = repository;
     this.postService = postService;
+    this.broker = broker;
+    this.redisCacheManager = redisCacheManager;
+    this.redisClient = redisClient;
+    this.inngestClient = inngestClient;
+    this.logger = logger?.child({
+      className: 'ChannelService'
+    }) || console;
+  }
+  /**
+   * Disposes of resources used by the service
+   */
+  dispose() {
+    this.toDispose.dispose();
+  }
+  /**
+   * 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
+   */
+  async callAction(command, params, topic, opts) {
+    try {
+      if (!this.broker) {
+        throw new Error('Service broker not available');
+      }
+      const actionName = topic ? `${topic}.${command}` : command;
+      return await this.broker.call(actionName, params, opts);
+    } catch (error) {
+      this.logger.error(`Error calling action ${command}: %o`, error);
+      throw error;
+    }
   }
+  /**
+   * 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
+   */
   async isMember(channelId, user) {
-    const channel = await this.get(channelId);
-    return !!channel?.members?.find(member => member.user.toString() === user.toString());
-  }
-  static getDmNameFromIds(senderId, receiverId) {
-    return `${senderId}__${receiverId}`;
+    try {
+      if (!channelId || !user) {
+        this.logger.warn('Channel ID and user ID are required for membership check');
+        return false;
+      }
+      this.logger.debug('Checking channel membership', {
+        channelId,
+        userId: user
+      });
+      const channel = await this.get(channelId);
+      if (!channel?.members) {
+        this.logger.debug('Channel not found or has no members', {
+          channelId
+        });
+        return false;
+      }
+      const isMember = !!channel.members.find(member => member.user && member.user.toString() === user.toString());
+      this.logger.debug('Channel membership check result', {
+        channelId,
+        userId: user,
+        isMember
+      });
+      return isMember;
+    } catch (error) {
+      this.logger.error('Error checking channel membership: %o', error);
+      return false;
+    }
   }
+  /**
+   * Enhanced method to get default notification properties
+   *
+   * @description Retrieves default notification settings with extensibility
+   *
+   * @returns {INotificationProps} - Default notification properties
+   */
   get defaultNotifyProps() {
-    // #Todo: To be moved to settings
-    return DEFAULT_NOTIFY_PROPS;
+    try {
+      // Future enhancement: Load from user preferences or organization settings
+      return DEFAULT_NOTIFY_PROPS;
+    } catch (error) {
+      this.logger.error('Error getting default notification props: %o', error);
+      return DEFAULT_NOTIFY_PROPS;
+    }
   }
-  static getMaxChannelsPerTeam(teamId) {
-    // #Todo: Get Max Channel per team from Team settings
-    return Promise.resolve(10);
+  /**
+   * 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
+   */
+  static async getMaxChannelsPerTeam(teamId) {
+    try {
+      // Future enhancement: Get from team settings or organization configuration
+      return Promise.resolve(100); // Default max channels per team
+    } catch (error) {
+      console.error('Error getting max channels per team:', error);
+      return Promise.resolve(10); // Fallback value
+    }
   }
+  /**
+   * 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
+   */
   async getCurrentChannelCountPerTeam(team) {
-    return this.repository.count({
-      team,
-      type: RoomType.Channel
-    });
+    try {
+      if (!team) {
+        this.logger.warn('Team ID is required for channel count');
+        return 0;
+      }
+      const count = await this.repository.count({
+        team,
+        type: RoomType.Channel,
+        deletedAt: {
+          $exists: false
+        } // Only count non-deleted channels
+      });
+      this.logger.debug('Current channel count for team', {
+        team,
+        count
+      });
+      return count;
+    } catch (error) {
+      this.logger.error('Error getting current channel count per team: %o', error);
+      return 0;
+    }
+  }
+  /**
+   * 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
+   */
+  static getDmNameFromIds(senderId, receiverId) {
+    try {
+      if (!senderId || !receiverId) {
+        throw new Error('Both sender and receiver IDs are required');
+      }
+      // Sort IDs to ensure consistent naming regardless of order
+      const [id1, id2] = [senderId, receiverId].sort();
+      return `${id1}__${id2}`;
+    } catch (error) {
+      console.error('Error generating DM name:', error);
+      return `${senderId}__${receiverId}`;
+    }
   }
+  /**
+   * 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
+   */
   async createDirectChannel(data) {
-    const {
-      sender,
-      receiver,
-      displayName,
-      orgName,
-      channelOptions
-    } = data;
-    const chlMember = [{
-      user: sender,
-      schemeAdmin: channelOptions?.schemeAdmin || false,
-      notifyProps: this.defaultNotifyProps
-    }];
-    receiver.forEach(re => {
-      if (re != sender) {
-        chlMember.push({
-          user: re,
-          schemeAdmin: channelOptions?.schemeAdmin || false,
-          notifyProps: this.defaultNotifyProps
+    try {
+      this.logger.debug('Creating direct channel', {
+        sender: data.sender,
+        receiverCount: data.receiver?.length || 0,
+        orgName: data.orgName
+      });
+      const {
+        sender,
+        receiver,
+        displayName,
+        orgName,
+        channelOptions
+      } = data;
+      if (!sender) {
+        return new Error('Sender ID is required');
+      }
+      if (!receiver || receiver.length === 0) {
+        return new Error('At least one receiver is required');
+      }
+      // Check for duplicate direct channel
+      const existingChannelName = ChannelService_1.getDmNameFromIds(sender, receiver[0]);
+      const existingChannel = await this.getByName(existingChannelName);
+      if (existingChannel) {
+        this.logger.debug('Direct channel already exists', {
+          channelName: existingChannelName
         });
+        return existingChannel;
       }
-    });
-    const channelPayload = {
-      title: sender.split('').reverse().join(''),
-      orgName,
-      type: RoomType.Direct,
-      creator: sender,
-      members: chlMember,
-      displayName
-    };
-    return this.saveDirectChannel(channelPayload);
+      // Build channel members
+      const channelMembers = [{
+        user: sender,
+        schemeAdmin: channelOptions?.schemeAdmin || false,
+        notifyProps: this.defaultNotifyProps
+      }];
+      receiver.forEach(receiverId => {
+        if (receiverId !== sender) {
+          channelMembers.push({
+            user: receiverId,
+            schemeAdmin: channelOptions?.schemeAdmin || false,
+            notifyProps: this.defaultNotifyProps
+          });
+        }
+      });
+      const channelPayload = {
+        title: displayName || ChannelService_1.getDmNameFromIds(sender, receiver[0]),
+        orgName,
+        organization: orgName,
+        type: RoomType.Direct,
+        creator: sender,
+        members: channelMembers,
+        displayName: displayName || `Direct chat`,
+        _id: undefined // Allow repository to generate
+      };
+      const result = await this.saveDirectChannel(channelPayload);
+      if (!(result instanceof Error)) {
+        this.onChannelCreated.fire({
+          channel: result,
+          userContext: {
+            accountId: sender,
+            tenantId: orgName
+          }
+        });
+      }
+      return result;
+    } catch (error) {
+      this.logger.error('Error creating direct channel: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while creating direct channel');
+    }
   }
+  /**
+   * 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
+   */
   async saveDirectChannel(channel) {
-    const {
-      type,
-      deletedAt
-    } = channel;
-    if (deletedAt) {
-      throw new Error('Deleted Channel can not be saved');
-    }
-    if (type !== RoomType.Direct) {
-      throw new Error('Only direct channels are allowed');
+    try {
+      this.logger.debug('Saving direct channel', {
+        type: channel.type,
+        creator: channel.creator,
+        memberCount: channel.members?.length || 0
+      });
+      const {
+        type,
+        deletedAt
+      } = channel;
+      if (deletedAt) {
+        return new Error('Deleted channels cannot be saved');
+      }
+      if (type !== RoomType.Direct) {
+        return new Error('Only direct channels are allowed in this method');
+      }
+      const result = await this.repository.create(channel);
+      this.logger.debug('Direct channel saved successfully', {
+        channelId: result.id,
+        type: result.type
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error saving direct channel: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while saving direct channel');
     }
-    return this.repository.create(channel);
   }
+  /**
+   * 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
+   */
   async addMemberToChannel(channelId, memberId) {
-    // const { channelId, memberId } = data;
-    // console.log('==============================', channelId);
-    const resData = await this.repository.get({
-      id: channelId
-    }).then(async res => {
-      const mebs = res.members;
-      mebs.push({
-        id: '',
-        user: memberId,
-        schemeAdmin: false,
-        notifyProps: this.defaultNotifyProps
+    try {
+      this.logger.debug('Adding member to channel', {
+        channelId,
+        memberId
       });
-      const objToUpdate = res;
-      objToUpdate.members = mebs;
-      const finalResult = await this.repository.update({
+      if (!channelId || !memberId) {
+        return new Error('Channel ID and member ID are required');
+      }
+      // Check if member is already in channel
+      const isMember = await this.isMember(channelId, memberId);
+      if (isMember) {
+        this.logger.debug('Member already exists in channel', {
+          channelId,
+          memberId
+        });
+        return await this.get(channelId);
+      }
+      const resData = await this.repository.get({
         id: channelId
-      }, objToUpdate, {
-        overwrite: true
-      }).then(response => response).catch(error => error);
-      return finalResult;
-    }).catch(err => err);
-    return resData;
+      }).then(async res => {
+        if (!res) {
+          throw new Error(`Channel ${channelId} not found`);
+        }
+        const members = res.members || [];
+        members.push({
+          user: memberId,
+          schemeAdmin: false,
+          notifyProps: this.defaultNotifyProps
+        });
+        const objToUpdate = {
+          ...res,
+          members
+        };
+        const finalResult = await this.repository.update({
+          id: channelId
+        }, objToUpdate, {
+          overwrite: true
+        });
+        return finalResult;
+      }).catch(err => {
+        this.logger.error('Error in addMemberToChannel operation: %o', err);
+        return err;
+      });
+      if (resData instanceof Error) {
+        return resData;
+      }
+      // Fire member added event
+      this.onMemberAdded.fire({
+        channelId,
+        memberId,
+        userContext: {
+          accountId: memberId
+        }
+      });
+      this.logger.debug('Member added to channel successfully', {
+        channelId,
+        memberId
+      });
+      return resData;
+    } catch (error) {
+      this.logger.error('Error adding member to channel: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred while adding member to channel');
+    }
   }
   async saveMembersToChannel(data) {
-    const {
-      channelId,
-      membersIds
-    } = data;
-    const resData = await this.repository.get({
-      id: channelId
-    }).then(async res => {
-      let mebs = res.members;
-      if (Array.isArray(membersIds)) {
-        if (membersIds?.length) {
-          membersIds.forEach(mid => {
-            mebs.push({
-              id: '',
-              user: mid,
-              schemeAdmin: false,
-              notifyProps: this.defaultNotifyProps
+    try {
+      const {
+        channelId,
+        membersIds
+      } = data;
+      const resData = await this.repository.get({
+        id: channelId
+      }).then(async res => {
+        let mebs = res.members || [];
+        if (Array.isArray(membersIds)) {
+          if (membersIds?.length) {
+            membersIds.forEach(mid => {
+              mebs.push({
+                user: mid,
+                schemeAdmin: false,
+                notifyProps: this.defaultNotifyProps
+              });
             });
-          });
+          }
         }
+        const objToUpdate = res;
+        objToUpdate.members = mebs;
+        const finalResult = await this.repository.update({
+          id: channelId
+        }, objToUpdate, {
+          overwrite: true
+        });
+        return finalResult;
+      }).catch(err => err);
+      if (resData instanceof Error) {
+        return resData;
       }
-      const objToUpdate = res;
-      objToUpdate.members = mebs;
-      const finalResult = await this.repository.update({
-        id: channelId
-      }, objToUpdate, {
-        overwrite: true
-      });
-      return finalResult;
-    }).catch(err => err);
-    return resData;
+      return resData;
+    } catch (error) {
+      this.logger.error('Error saving members to channel: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
   async saveChannel(data) {
-    const {
-      type,
-      team,
-      creator
-    } = data;
-    if (type === RoomType.Direct) {
-      throw new Error('Invalid Channel Type');
-    }
-    if (team) {
-      const maxChannels = await ChannelService_1.getMaxChannelsPerTeam(team);
-      const currentChannels = await this.getCurrentChannelCountPerTeam(team);
-      const canAddNewChannel = currentChannels < maxChannels;
-      if (!canAddNewChannel) {
-        throw Error(`Only max of ${maxChannels} allowed`);
+    try {
+      const {
+        type,
+        team,
+        creator
+      } = data;
+      if (type === RoomType.Direct) {
+        return new Error('Invalid Channel Type');
+      }
+      if (team) {
+        const maxChannels = await ChannelService_1.getMaxChannelsPerTeam(team);
+        const currentChannels = await this.getCurrentChannelCountPerTeam(team);
+        const canAddNewChannel = currentChannels < maxChannels;
+        if (!canAddNewChannel) {
+          return new Error(`Only max of ${maxChannels} allowed`);
+        }
       }
+      const channelPayload = {
+        ...data,
+        members: [{
+          user: creator,
+          schemeAdmin: false,
+          notifyProps: this.defaultNotifyProps
+        }]
+      };
+      const result = await this.repository.create(channelPayload);
+      return result;
+    } catch (error) {
+      this.logger.error('Error saving channel: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
     }
-    const channelPayload = {
-      ...data,
-      members: [{
-        user: creator,
-        schemeAdmin: false,
-        notifyProps: this.defaultNotifyProps
-      }]
-    };
-    return this.repository.create(channelPayload);
   }
   async savePublicChannel(data) {
-    const {
-      type
-    } = data;
-    if (type !== RoomType.Public) {
-      throw new Error('Invalid Channel Type');
+    try {
+      const {
+        type
+      } = data;
+      if (type !== RoomType.Public) {
+        return new Error('Invalid Channel Type');
+      }
+      const result = await this.repository.create(data);
+      return result;
+    } catch (error) {
+      this.logger.error('Error saving public channel: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
     }
-    return this.repository.create(data);
   }
   async getChannelUnread(channelId, userId) {
-    const channel = await this.repository.get({
-      id: channelId,
-      members: {
-        user: userId
+    try {
+      const channel = await this.repository.get({
+        id: channelId,
+        members: {
+          user: userId
+        }
+      }); // Type assertion to handle the interface mismatch
+      const {
+        members,
+        team,
+        id
+      } = channel;
+      const member = members?.find(i => i.user && i.user.toString() === userId);
+      if (!member) {
+        return {
+          channelId: id,
+          teamId: team ? team.toString() : '',
+          msgCount: 0,
+          msgCountRoot: 0,
+          mentionCount: 0,
+          notifyProps: this.defaultNotifyProps,
+          mentionCountRoot: 0
+        };
       }
-    });
-    const {
-      members,
-      team,
-      id
-    } = channel;
-    const member = members.find(i => i.user.toString() === userId);
-    const msgCount = channel.totalMsgCount - member.msgCount;
-    const msgCountRoot = channel.totalMsgCountRoot - member.msgCountRoot;
-    const {
-      notifyProps,
-      mentionCountRoot,
-      mentionCount
-    } = member;
-    return {
-      channelId: id,
-      teamId: team.toString(),
-      msgCount,
-      msgCountRoot,
-      mentionCount,
-      notifyProps,
-      mentionCountRoot
-    };
+      const msgCount = (channel.totalMsgCount || 0) - (member.msgCount || 0);
+      const msgCountRoot = (channel.totalMsgCountRoot || 0) - (member.msgCountRoot || 0);
+      const {
+        notifyProps,
+        mentionCountRoot,
+        mentionCount
+      } = member;
+      return {
+        channelId: id,
+        teamId: team ? team.toString() : '',
+        msgCount,
+        msgCountRoot,
+        mentionCount: mentionCount || 0,
+        notifyProps: notifyProps || this.defaultNotifyProps,
+        mentionCountRoot: mentionCountRoot || 0
+      };
+    } catch (error) {
+      this.logger.error('Error getting channel unread: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
   async getPinnedPosts(channelId) {
-    const posts = await this.postService.getAll({
-      criteria: {
-        channelId,
-        isPinned: true
-      },
-      sort: {
-        key: 'CreatAt',
-        value: SortEnum.Asc
-      }
-    });
-    const replyCounts = await Promise.all(posts.map(post => this.postService.count({
-      rootId: post.rootId || post.id
-    })));
-    return posts.reduce((acc, curr, index) => [...acc, {
-      ...curr,
-      replyCount: replyCounts[index]
-    }], []);
-  }
-  restore(channelId, time) {
-    return this.repository.update({
-      id: channelId
-    }, {
-      deletedAt: time
-    });
-  }
-  // getByName(team: string, title: string): Promise<IChannel> {
-  //     return this.get({
-  //         team,
-  //         title,
-  //     });
-  // }
-  getByName(title) {
-    return this.get({
-      title
-    });
-  }
-  getByNameIncludeDeleted(team, title) {
-    return this.get({
-      team,
-      title,
-      deletedAt: true
-    });
+    try {
+      const posts = await this.postService.getAll({
+        criteria: {
+          channelId,
+          isPinned: true
+        },
+        sort: {
+          key: 'CreatAt',
+          value: SortEnum.Asc
+        }
+      });
+      const replyCounts = await Promise.all(posts.map(post => this.postService.count({
+        rootId: post.rootId || post._id
+      })));
+      return posts.reduce((acc, curr, index) => [...acc, {
+        ...curr,
+        replyCount: replyCounts[index]
+      }], []);
+    } catch (error) {
+      this.logger.error('Error getting pinned posts: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
-  getByNames(team, titles) {
-    return this.getAll({
-      criteria: {
-        team,
-        title: {
-          $in: titles
+  async getFromMaster(id) {
+    try {
+      // Try Redis cache first
+      if (this.redisCacheManager && id) {
+        try {
+          const cacheKey = `${config.APP_NAME}:getChannelById`;
+          const variables = {
+            id
+          };
+          const cacheCtx = {
+            userId: 'system'
+          };
+          const cached = await this.redisCacheManager.get(cacheKey, variables, cacheCtx);
+          if (cached) {
+            this.logger.debug(`Cache hit for channel ID: ${id}`);
+            return cached;
+          }
+        } catch (cacheError) {
+          this.logger.warn(`Redis cache error for getFromMaster(${id}): ${cacheError?.message}`);
+        }
+      }
+      const result = await this.get({
+        id
+      });
+      // Set cache
+      if (this.redisCacheManager && result) {
+        try {
+          const cacheKey = `${config.APP_NAME}:getChannelById`;
+          const variables = {
+            id
+          };
+          const cacheCtx = {
+            userId: 'system'
+          };
+          await this.redisCacheManager.set(cacheKey, variables, result, cacheCtx, CACHE_TTL);
+        } catch (cacheError) {
+          this.logger.warn(`Failed to cache channel by id: ${cacheError?.message}`);
         }
       }
-    });
+      return result;
+    } catch (error) {
+      this.logger.error('Error getting channel from master: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
-  getChannelCounts(team, user) {
-    return this.count({
-      team,
-      members: {
-        user
+  async restore(channelId, time) {
+    try {
+      await this.repository.update({
+        id: channelId
+      }, {
+        deletedAt: time
+      });
+    } catch (error) {
+      this.logger.error('Error restoring channel: %o', error);
+      throw error;
+    }
+  }
+  // @ts-ignore - Type compatibility issue with base class method
+  async getByName(title) {
+    try {
+      if (!title) {
+        this.logger.warn('Empty channel title provided');
+        return null;
       }
-    });
+      // Try Redis cache first
+      if (this.redisCacheManager) {
+        try {
+          const cacheKey = `${config.APP_NAME}:getChannelByName`;
+          const variables = {
+            name: title
+          };
+          const cacheCtx = {
+            userId: 'system'
+          };
+          const cached = await this.redisCacheManager.get(cacheKey, variables, cacheCtx);
+          if (cached) {
+            this.logger.debug(`Cache hit for channel name: ${title}`);
+            return cached;
+          }
+        } catch (cacheError) {
+          this.logger.warn(`Redis cache error for getByName(${title}): ${cacheError?.message}`);
+        }
+      }
+      const result = await this.get({
+        title
+      });
+      // Cache the result
+      if (this.redisCacheManager && result) {
+        try {
+          const cacheKey = `${config.APP_NAME}:getChannelByName`;
+          const variables = {
+            name: title
+          };
+          const cacheCtx = {
+            userId: 'system'
+          };
+          await this.redisCacheManager.set(cacheKey, variables, result, cacheCtx, CACHE_TTL);
+        } catch (cacheError) {
+          this.logger.warn(`Failed to cache channel by name: ${cacheError?.message}`);
+        }
+      }
+      return result;
+    } catch (error) {
+      this.logger.error('Error getting channel by name: %o', error);
+      throw error;
+    }
   }
-  getChannels(team, user, includeDeleted, lastDeleteAt, orgName) {
-    return this.repository.getAll({
-      criteria: this.generateCriteria({
-        team,
-        user,
-        includeDeleted,
-        lastDeleteAt,
-        orgName
-      })
-    });
+  async getByNameIncludeDeleted(teamId, name) {
+    try {
+      const result = await this.get({
+        team: teamId,
+        title: name,
+        deletedAt: true
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error getting channel by name including deleted: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
+  }
+  async getByNames(teamId, names) {
+    try {
+      const result = await this.getAll({
+        criteria: {
+          team: teamId,
+          title: {
+            $in: names
+          }
+        }
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error getting channels by names: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
+  }
+  async getChannelCounts(teamId, userId) {
+    try {
+      return await this.count({
+        team: teamId,
+        members: {
+          user: userId
+        }
+      });
+    } catch (error) {
+      this.logger.error('Error getting channel counts: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
+  }
+  async getChannels(teamId, userId, includeDeleted, lastDeleteAt, orgId) {
+    try {
+      const result = await this.repository.getAll({
+        criteria: this.generateCriteria({
+          team: teamId,
+          user: userId,
+          includeDeleted,
+          lastDeleteAt,
+          orgName: orgId
+        })
+      });
+      return result;
+    } catch (error) {
+      this.logger.error('Error getting channels: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
   generateCriteria(options) {
     const {
@@ -323,72 +771,193 @@ let ChannelService = ChannelService_1 = class ChannelService extends BaseService
     }
     return criteria;
   }
-  deleteChannel(id) {
-    return this.repository.delete({
-      id
-    });
+  async deleteChannel(id) {
+    try {
+      return await this.repository.delete({
+        id
+      });
+    } catch (error) {
+      this.logger.error('Error deleting channel: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
-  getDeleted(teamId, offset, limit, userId) {
-    return Promise.resolve(undefined);
+  async getDeleted(teamId, offset, limit, userId) {
+    try {
+      // Implementation would go here to get deleted channels
+      return [];
+    } catch (error) {
+      this.logger.error('Error getting deleted channels: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
-  getDeletedByName(teamId, name) {
-    return Promise.resolve(undefined);
+  async getDeletedByName(teamId, name) {
+    try {
+      // Implementation would go here
+      return null;
+    } catch (error) {
+      this.logger.error('Error getting deleted channel by name: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
-  getFromMaster(id) {
-    return Promise.resolve(undefined);
+  async getMoreChannels(teamId, userId, offset, limit) {
+    try {
+      // Implementation would go here
+      return [];
+    } catch (error) {
+      this.logger.error('Error getting more channels: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
-  getMoreChannels(teamId, userId, offset, limit) {
-    return Promise.resolve(undefined);
+  async getPrivateChannelsForTeam(teamId, offset, limit) {
+    try {
+      // Implementation would go here
+      return [];
+    } catch (error) {
+      this.logger.error('Error getting private channels for team: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
-  getPrivateChannelsForTeam(teamId, offset, limit) {
-    return Promise.resolve(undefined);
+  async getPublicChannelsByIdsForTeam(teamId, channelsIds) {
+    try {
+      // Implementation would go here
+      return [];
+    } catch (error) {
+      this.logger.error('Error getting public channels by IDs for team: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
-  getPublicChannelsByIdsForTeam(teamId, channelsIds) {
-    return Promise.resolve(undefined);
+  async getPublicChannelsForTeam(teamId, offset, limit) {
+    try {
+      // Implementation would go here
+      return [];
+    } catch (error) {
+      this.logger.error('Error getting public channels for team: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
-  getPublicChannelsForTeam(teamId, offset, limit) {
-    return Promise.resolve(undefined);
+  async getTeamChannels(teamId) {
+    try {
+      // Implementation would go here
+      return [];
+    } catch (error) {
+      this.logger.error('Error getting team channels: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
-  getTeamChannels(teamId) {
-    return Promise.resolve(undefined);
+  async hideChannel(id) {
+    try {
+      // Implementation would go here
+      return false;
+    } catch (error) {
+      this.logger.error('Error hiding channel: %o', error);
+      return false;
+    }
   }
-  hideChannel(id) {
-    return Promise.resolve(false);
+  async leaveChannel(id) {
+    try {
+      // Implementation would go here
+      return false;
+    } catch (error) {
+      this.logger.error('Error leaving channel: %o', error);
+      return false;
+    }
   }
-  invalidateChannelByName(teamId, name) {
-    return Promise.resolve();
+  async viewChannel(id, user) {
+    try {
+      // Accessing private property
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      if (id) {
+        await this.repository.model.updateOne({
+          _id: id
+        }, {
+          'members.$[elem].lastViewedAt': new Date()
+        }, {
+          arrayFilters: [{
+            'elem.user': user
+          }]
+        });
+      }
+      return true;
+    } catch (error) {
+      this.logger.error('Error viewing channel: %o', error);
+      return false;
+    }
   }
-  leaveChannel(id) {
-    return Promise.resolve(false);
+  async permanentDelete(channelId) {
+    try {
+      // Implementation would go here for permanent deletion
+      this.logger.debug(`Permanently deleting channel ${channelId}`);
+    } catch (error) {
+      this.logger.error('Error permanently deleting channel: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
-  async viewChannel(id, user) {
-    // Accessing private property
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    if (id) {
-      await this.repository.model.updateOne({
-        _id: id
-      }, {
-        'members.$[elem].lastViewedAt': new Date()
-      }, {
-        arrayFilters: [{
-          'elem.user': user
-        }]
-      });
+  async permanentDeleteByTeam(teamId) {
+    try {
+      // Implementation would go here for permanent team deletion
+      this.logger.debug(`Permanently deleting all channels for team ${teamId}`);
+    } catch (error) {
+      this.logger.error('Error permanently deleting channels by team: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
     }
-    return true;
   }
-  permanentDelete(channelId) {
-    return undefined;
+  async permanentDeleteMembersByChannel(channelId) {
+    try {
+      // Implementation would go here for permanent member deletion
+      this.logger.debug(`Permanently deleting all members for channel ${channelId}`);
+    } catch (error) {
+      this.logger.error('Error permanently deleting members by channel: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
-  permanentDeleteByTeam(teamId) {
-    return undefined;
+  async saveMultipleMembers(members) {
+    try {
+      // Implementation would go here
+      return [];
+    } catch (error) {
+      this.logger.error('Error saving multiple members: %o', error);
+      return error instanceof Error ? error : new Error('Unknown error occurred');
+    }
   }
-  permanentDeleteMembersByChannel(channelId) {
-    return undefined;
+  async invalidateChannelByName(teamId, name) {
+    try {
+      if (!this.redisCacheManager) {
+        return;
+      }
+      // Invalidate name-based cache
+      await this.redisCacheManager.del(`${config.APP_NAME}:getChannelByName`, {
+        name
+      }, {
+        userId: 'system'
+      }, true);
+      // If we have team-specific variations in future, consider invalidating those keys as well
+      this.logger.debug(`Invalidated channel cache for name ${name} (team: ${teamId || 'n/a'})`);
+    } catch (error) {
+      this.logger.warn(`Error invalidating channel cache: ${error?.message}`);
+    }
   }
-  saveMultipleMembers(members) {
-    return Promise.resolve(undefined);
+  async createChannelWithProjectId(projectId, channelInput) {
+    try {
+      if (!this.inngestClient) {
+        return false;
+      }
+      const result = await this.inngestClient.send({
+        name: 'channel-with-project-id.create',
+        data: {
+          projectId,
+          channelInput
+        }
+      });
+      // Inngest send() typically returns an object with dispatched ids
+      const ok = !!result?.ids?.length;
+      return ok;
+    } catch (error) {
+      this.logger.error('Error creating channel with project ID: %o', error);
+      return false;
+    }
   }
 };
-ChannelService = ChannelService_1 = __decorate([__param(0, inject(SERVER_TYPES.ChannelRepository)), __param(1, inject(SERVER_TYPES.PostService)), __metadata("design:paramtypes", [Object, Object])], ChannelService);export{ChannelService};//# sourceMappingURL=channel-service.js.map
+ChannelService = ChannelService_1 = __decorate([injectable()
+// @ts-ignore - Type compatibility issue between BaseService2 and IChannelService
+, __param(0, inject(SERVER_TYPES.ChannelRepository)), __param(1, inject(SERVER_TYPES.PostService)), __param(2, inject(CommonType.MOLECULER_BROKER)), __param(3, inject(SERVER_TYPES.IRedisCacheManager)), __param(4, inject(CommonType.REDIS_CLIENT)), __param(5, inject('Logger')), __param(6, inject(CommonType.INNGEST_CLIENT)), __metadata("design:paramtypes", [Object, Object, ServiceBroker, Object, Function, Object, Object])], ChannelService);export{ChannelService};//# sourceMappingURL=channel-service.js.map