src/server/api/router.ts

import { createTaskService } from '@/server/services/tasks';
import { queueHealth } from '@/server/jobs/health';
import {
  createExportSchema,
  taskIdSchema,
  taskListSchema,
  reminderScheduleSchema,
} from '@/shared/tasks';
import { requireMembership } from '@/server/services/access';
import { t, protectedProcedure } from './trpc';
import {
  createTicketSchema,
  ticketIdSchema,
  listTicketsSchema,
  updateTicketStatusSchema,
  assignTicketSchema,
  createReplySchema,
  listRepliesSchema,
  listTicketEventsSchema,
} from '@/shared/ticket';
import { createTeamService } from '@/server/services/team';
import {
  teamScopeSchema,
  createTeamSchema,
  addMemberSchema,
  changeMemberSchema,
  removeMemberSchema,
} from '@/shared/team';
import { createCollaborationService } from '@/server/services/collaboration';
import { createTicketEventService } from '@/server/services/ticket-events';
import { createTicketService } from '@/server/services/ticket';

export const appRouter = t.router({
  task: t.router({
    createExport: protectedProcedure
      .input(createExportSchema.merge(teamScopeSchema))
      .mutation(({ ctx, input }) =>
        createTaskService(ctx.db, ctx.userId, input.teamId).createExport(
          input.filters,
        ),
      ),
    list: protectedProcedure
      .input(taskListSchema.merge(teamScopeSchema))
      .query(({ ctx, input }) =>
        createTaskService(ctx.db, ctx.userId, input.teamId).list(input),
      ),
    retry: protectedProcedure
      .input(taskIdSchema.merge(teamScopeSchema))
      .mutation(({ ctx, input }) =>
        createTaskService(ctx.db, ctx.userId, input.teamId).retry(input.id),
      ),
    schedule: protectedProcedure
      .input(reminderScheduleSchema.merge(teamScopeSchema))
      .mutation(({ ctx, input }) =>
        createTaskService(ctx.db, ctx.userId, input.teamId).schedule(input),
      ),
    notifications: protectedProcedure
      .input(teamScopeSchema)
      .query(({ ctx, input }) =>
        createTaskService(ctx.db, ctx.userId, input.teamId).notifications(),
      ),
    read: protectedProcedure
      .input(taskIdSchema.merge(teamScopeSchema))
      .mutation(({ ctx, input }) =>
        createTaskService(ctx.db, ctx.userId, input.teamId).read(input.id),
      ),
    health: protectedProcedure
      .input(teamScopeSchema)
      .query(async ({ ctx, input }) => {
        await requireMembership(ctx.db, ctx.userId, input.teamId);
        return queueHealth();
      }),
  }),
  team: t.router({
    list: protectedProcedure.query(({ ctx }) =>
      createTeamService(ctx.db, ctx.userId).list(),
    ),
    create: protectedProcedure
      .input(createTeamSchema)
      .mutation(({ ctx, input }) =>
        createTeamService(ctx.db, ctx.userId).create(input.name),
      ),
    members: protectedProcedure
      .input(teamScopeSchema)
      .query(({ ctx, input }) =>
        createTeamService(ctx.db, ctx.userId).members(input.teamId),
      ),
    addMember: protectedProcedure
      .input(addMemberSchema)
      .mutation(({ ctx, input }) =>
        createTeamService(ctx.db, ctx.userId).add(input),
      ),
    changeRole: protectedProcedure
      .input(changeMemberSchema)
      .mutation(({ ctx, input }) =>
        createTeamService(ctx.db, ctx.userId).change(input),
      ),
    removeMember: protectedProcedure
      .input(removeMemberSchema)
      .mutation(({ ctx, input }) =>
        createTeamService(ctx.db, ctx.userId).change(input),
      ),
  }),
  ticket: t.router({
    events: protectedProcedure
      .input(listTicketEventsSchema.merge(teamScopeSchema))
      .query(({ ctx, input }) =>
        createTicketEventService(ctx.db, ctx.userId, input.teamId).list(input),
      ),
    assignees: protectedProcedure
      .input(teamScopeSchema)
      .query(({ ctx, input }) =>
        createCollaborationService(
          ctx.db,
          ctx.userId,
          input.teamId,
        ).assignees(),
      ),
    assign: protectedProcedure
      .input(assignTicketSchema.merge(teamScopeSchema))
      .mutation(({ ctx, input }) =>
        createCollaborationService(ctx.db, ctx.userId, input.teamId).assign(
          input,
        ),
      ),
    replies: protectedProcedure
      .input(listRepliesSchema.merge(teamScopeSchema))
      .query(({ ctx, input }) =>
        createCollaborationService(ctx.db, ctx.userId, input.teamId).replies(
          input,
        ),
      ),
    reply: protectedProcedure
      .input(createReplySchema.merge(teamScopeSchema))
      .mutation(({ ctx, input }) =>
        createCollaborationService(ctx.db, ctx.userId, input.teamId).reply(
          input,
        ),
      ),
    // input(schema) 会先运行 Zod；不合法的请求到不了后面的业务代码。
    // ctx 是每次请求携带的服务端依赖，类似 React context，但不会传给浏览器。
    create: protectedProcedure
      .input(createTicketSchema.merge(teamScopeSchema))
      .mutation(({ ctx, input }) =>
        createTicketService(ctx.db, ctx.userId, input.teamId).create({
          title: input.title,
          description: input.description,
          priority: input.priority,
        }),
      ),
    list: protectedProcedure
      .input(listTicketsSchema.merge(teamScopeSchema))
      .query(({ ctx, input }) =>
        createTicketService(ctx.db, ctx.userId, input.teamId).list(input),
      ),
    detail: protectedProcedure
      .input(ticketIdSchema.merge(teamScopeSchema))
      .query(({ ctx, input }) =>
        createTicketService(ctx.db, ctx.userId, input.teamId).detail(input.id),
      ),
    updateStatus: protectedProcedure
      .input(updateTicketStatusSchema.merge(teamScopeSchema))
      .mutation(({ ctx, input }) =>
        createTicketService(ctx.db, ctx.userId, input.teamId).updateStatus(
          input,
        ),
      ),
  }),
});
export type AppRouter = typeof appRouter;