重命名 Sender 实体为 TgUser，并更新相关引用，增强代码一致性。同时，将 GroupTaskItem 中的 senderId 字段重命名为 inviterId，以更准确地反映其含义。

src/entities/group-task-item.entity.ts

@@ -24,7 +24,7 @@ export class GroupTaskItem {
   status: GroupTaskItemStatus
 
   @Column({ type: 'bigint', nullable: true })
-  senderId: string | null
+  inviterId: string | null
 
   @Column({ type: 'text', nullable: true })
   errorMsg: string | null

src/entities/sender.entity.ts

@@ -2,7 +2,7 @@ import { Column, Entity, Index, PrimaryColumn } from 'typeorm'
 
 @Entity()
 @Index('idx_sender_del_usage_last', ['delFlag', 'usageCount', 'lastUsageTime'])
-export class Sender {
+export class TgUser {
   @PrimaryColumn({ type: 'bigint' })
   id: string
 

src/executor/task.executor.ts

@@ -3,7 +3,7 @@ import { Repository } from 'typeorm'
 import { TelegramClient, Api } from 'telegram'
 import { Task, TaskStatus } from '../entities/task.entity'
 import { TaskItem, TaskItemStatus } from '../entities/task-item.entity'
-import { Sender } from '../entities/sender.entity'
+import { TgUser } from '../entities/sender.entity'
 import { SenderService } from '../services/sender.service'
 import { TgClientService } from '../services/tgClient.service'
 import { buildStringSessionByDcIdAndAuthKey } from '../utils/tg.util'
@@ -11,21 +11,21 @@ import { buildStringSessionByDcIdAndAuthKey } from '../utils/tg.util'
 export class TaskExecutor {
   private taskRepo: Repository<Task>
   private taskItemRepo: Repository<TaskItem>
-  private senderRepo: Repository<Sender>
+  private senderRepo: Repository<TgUser>
   private senderService: SenderService
 
   private readonly defaultSenderSendLimit = 5
   private currentSenderSendLimit = this.defaultSenderSendLimit
   private senderUsageInBatch: Map<string, number> = new Map()
   private senderCursor = 0
-  private senderCache: Sender[] = []
+  private senderCache: TgUser[] = []
 
   constructor(private app: FastifyInstance) {
     const ds = app.dataSource
     this.senderService = new SenderService(app)
     this.taskRepo = ds.getRepository(Task)
     this.taskItemRepo = ds.getRepository(TaskItem)
-    this.senderRepo = ds.getRepository(Sender)
+    this.senderRepo = ds.getRepository(TgUser)
   }
 
   /**
@@ -85,7 +85,7 @@ export class TaskExecutor {
    * 单 worker 循环
    */
   private async workerLoop(taskId: number): Promise<void> {
-    let sender: Sender | null = null
+    let sender: TgUser | null = null
     const workerTgClient = new TgClientService()
     let senderSentInRound = 0
     const sendIntervalMs = await this.getSendInterval(taskId)
@@ -201,7 +201,7 @@ export class TaskExecutor {
   private async processTaskItem(
     task: Task,
     item: TaskItem,
-    sender: Sender,
+    sender: TgUser,
     workerTgClient: TgClientService
   ): Promise<void> {
     try {
@@ -305,7 +305,7 @@ export class TaskExecutor {
   /**
    * 选择可用的发送者
    */
-  private async pickSender(): Promise<Sender> {
+  private async pickSender(): Promise<TgUser> {
     if (this.senderCache.length === 0) {
       this.senderCache = await this.senderRepo.find({
         where: { delFlag: false },
@@ -338,7 +338,7 @@ export class TaskExecutor {
   /**
    * 确保发送者有有效的会话字符串
    */
-  private async ensureSessionString(sender: Sender): Promise<string> {
+  private async ensureSessionString(sender: TgUser): Promise<string> {
     if (sender.sessionStr) {
       return sender.sessionStr
     }
@@ -355,7 +355,7 @@ export class TaskExecutor {
   /**
    * 处理会话被撤销的情况
    */
-  private async handleSessionRevoked(sender: Sender): Promise<void> {
+  private async handleSessionRevoked(sender: TgUser): Promise<void> {
     await this.senderRepo.update(sender.id, { delFlag: true })
     this.senderCache = this.senderCache.filter(s => s.id !== sender.id)
     this.senderCursor = 0

src/services/sender.service.ts

@@ -1,17 +1,17 @@
 import { Repository } from 'typeorm'
 import { FastifyInstance } from 'fastify'
-import { Sender } from '../entities/sender.entity'
+import { TgUser } from '../entities/sender.entity'
 import { PaginationResponse } from '../dto/common.dto'
 import { buildStringSessionByDcIdAndAuthKey } from '../utils/tg.util'
 
 export class SenderService {
-  private senderRepository: Repository<Sender>
+  private senderRepository: Repository<TgUser>
 
   constructor(app: FastifyInstance) {
-    this.senderRepository = app.dataSource.getRepository(Sender)
+    this.senderRepository = app.dataSource.getRepository(TgUser)
   }
 
-  async create(id: string, dcId?: number, authKey?: string, sessionStr?: string): Promise<Sender> {
+  async create(id: string, dcId?: number, authKey?: string, sessionStr?: string): Promise<TgUser> {
     const sender = this.senderRepository.create({
       id,
       dcId,
@@ -24,11 +24,11 @@ export class SenderService {
     return this.senderRepository.save(sender)
   }
 
-  async findById(id: string): Promise<Sender | null> {
+  async findById(id: string): Promise<TgUser | null> {
     return this.senderRepository.findOne({ where: { id } })
   }
 
-  async findAll(page: number, size: number, delFlag?: boolean): Promise<PaginationResponse<Sender>> {
+  async findAll(page: number, size: number, delFlag?: boolean): Promise<PaginationResponse<TgUser>> {
     const where: any = {}
     if (delFlag !== undefined) {
       where.delFlag = delFlag
@@ -53,7 +53,7 @@ export class SenderService {
     }
   }
 
-  async update(id: string, data: Partial<Sender>): Promise<Sender> {
+  async update(id: string, data: Partial<TgUser>): Promise<TgUser> {
     await this.senderRepository.update(id, data)
     const sender = await this.findById(id)
     if (!sender) {
@@ -70,7 +70,7 @@ export class SenderService {
     await this.senderRepository.delete(id)
   }
 
-  async incrementUsageCount(id: string): Promise<Sender> {
+  async incrementUsageCount(id: string): Promise<TgUser> {
     const sender = await this.findById(id)
     if (!sender) {
       throw new Error('Sender not found')
@@ -80,7 +80,7 @@ export class SenderService {
     return this.senderRepository.save(sender)
   }
 
-  async pickAvailableSender(): Promise<Sender | null> {
+  async pickAvailableSender(): Promise<TgUser | null> {
     const sender = await this.senderRepository.findOne({
       where: { delFlag: false },
       order: {

src/services/test.service.ts

@@ -5,7 +5,7 @@ import { StringSession } from 'telegram/sessions'
 import bigInt from 'big-integer'
 import { Task, TaskStatus } from '../entities/task.entity'
 import { TaskItem, TaskItemStatus } from '../entities/task-item.entity'
-import { Sender } from '../entities/sender.entity'
+import { TgUser } from '../entities/sender.entity'
 import { SenderService } from './sender.service'
 import { TgClientService } from './tgClient.service'
 import { ChatGroupService } from './chat-group.service'
@@ -15,20 +15,20 @@ export class TestService {
   private readonly app: FastifyInstance
   private readonly taskRepository: Repository<Task>
   private readonly taskItemRepository: Repository<TaskItem>
-  private readonly senderRepository: Repository<Sender>
+  private readonly senderRepository: Repository<TgUser>
   private readonly senderService: SenderService
   private readonly tgClientService: TgClientService
   private readonly chatGroupService: ChatGroupService
   private senderSendLimit = 5
   private senderUsageInBatch: Map<string, number> = new Map()
   private senderCursor = 0
-  private senderCache: Sender[] = []
+  private senderCache: TgUser[] = []
 
   constructor(app: FastifyInstance) {
     this.app = app
     this.taskRepository = app.dataSource.getRepository(Task)
     this.taskItemRepository = app.dataSource.getRepository(TaskItem)
-    this.senderRepository = app.dataSource.getRepository(Sender)
+    this.senderRepository = app.dataSource.getRepository(TgUser)
     this.senderService = new SenderService(app)
     this.tgClientService = new TgClientService()
     this.chatGroupService = new ChatGroupService(app)
@@ -91,7 +91,7 @@ export class TestService {
       let totalSuccess = 0
       let totalFailed = 0
 
-      const pickSender = async (): Promise<Sender> => {
+      const pickSender = async (): Promise<TgUser> => {
         if (this.senderCache.length === 0) {
           this.senderCache = await this.senderRepository.find({
             where: { delFlag: false },
@@ -266,7 +266,7 @@ export class TestService {
           message: 'dcId 和 authKey 必须同时传参'
         }
       }
-      let sender: Sender | null = null
+      let sender: TgUser | null = null
       let sessionString: string | null = null
 
       if (session) {
@@ -1003,7 +1003,7 @@ export class TestService {
     session?: string,
     dcId?: number,
     authKey?: string
-  ): Promise<{ sender: Sender; sessionString: string } | { error: { success: false; message: string } }> {
+  ): Promise<{ sender: TgUser; sessionString: string } | { error: { success: false; message: string } }> {
     if ((dcId !== undefined && authKey === undefined) || (dcId === undefined && authKey !== undefined)) {
       return {
         error: {
@@ -1013,7 +1013,7 @@ export class TestService {
       }
     }
 
-    let sender: Sender | null = null
+    let sender: TgUser | null = null
     let sessionString: string | null = null
 
     if (session) {
@@ -1146,7 +1146,7 @@ export class TestService {
     return null
   }
 
-  private async pickSenderForTask(): Promise<Sender> {
+  private async pickSenderForTask(): Promise<TgUser> {
     if (this.senderCache.length === 0) {
       this.senderCache = await this.senderRepository.find({
         where: { delFlag: false },
@@ -1176,7 +1176,7 @@ export class TestService {
     return this.senderCache[0]
   }
 
-  private async ensureSessionStringForSender(sender: Sender): Promise<string> {
+  private async ensureSessionStringForSender(sender: TgUser): Promise<string> {
     if (sender.sessionStr) {
       return sender.sessionStr
     }

src/services/tg-group.service.ts

@@ -1,6 +1,6 @@
 import { FastifyInstance } from 'fastify'
 import { Repository } from 'typeorm'
-import { Sender } from '../entities/sender.entity'
+import { TgUser } from '../entities/sender.entity'
 import { TgClientService } from './tgClient.service'
 import { buildStringSessionByDcIdAndAuthKey } from '../utils/tg.util'
 import { TelegramClient } from 'telegram'
@@ -10,12 +10,12 @@ export class TgGroupService {
   private readonly app: FastifyInstance
   private readonly tgClientService: TgClientService
   private readonly chatGroupService: ChatGroupService
-  private readonly senderRepository: Repository<Sender>
+  private readonly senderRepository: Repository<TgUser>
   constructor(app: FastifyInstance) {
     this.app = app
     this.tgClientService = new TgClientService()
     this.chatGroupService = new ChatGroupService(app)
-    this.senderRepository = app.dataSource.getRepository(Sender)
+    this.senderRepository = app.dataSource.getRepository(TgUser)
   }
 
   async createTgGroup(
@@ -25,7 +25,7 @@ export class TgGroupService {
     initMsg?: string,
     senderId?: string
   ): Promise<any> {
-    let sender: Sender | null = null
+    let sender: TgUser | null = null
     let client: TelegramClient | null = null
 
     try {