ubiquitous-invention/apps/web/server/routers/workspaces.ts

import { TRPCError } from "@trpc/server";
import { z } from "zod";
import { and, eq } from "drizzle-orm";
import { objects, workspaceMembers, users } from "@tasks/database/schema";
import { router, protectedProcedure } from "@/server/trpc";

export const workspacesRouter = router({
  getById: protectedProcedure
    .input(z.object({ id: z.string().uuid() }))
    .query(async ({ ctx, input }) => {
      const [row] = await ctx.db
        .select({
          id: objects.id,
          title: objects.title,
          type: objects.type,
          icon: objects.icon,
        })
        .from(objects)
        .where(and(eq(objects.id, input.id), eq(objects.type, "workspace")))
        .limit(1);

      if (!row) {
        throw new TRPCError({ code: "NOT_FOUND", message: "Workspace not found" });
      }

      return row;
    }),

  listForUser: protectedProcedure.query(async ({ ctx }) => {
    const userId = ctx.session.user.id;

    return ctx.db
      .select({
        id: objects.id,
        title: objects.title,
        icon: objects.icon,
        role: workspaceMembers.role,
      })
      .from(workspaceMembers)
      .innerJoin(objects, eq(workspaceMembers.workspaceId, objects.id))
      .where(eq(workspaceMembers.userId, userId));
  }),

  listMembers: protectedProcedure
    .input(z.object({ workspaceId: z.string().uuid() }))
    .query(async ({ ctx, input }) => {
      return ctx.db
        .select({
          id: users.id,
          name: users.name,
          email: users.email,
          avatarUrl: users.avatarUrl,
          role: workspaceMembers.role,
        })
        .from(workspaceMembers)
        .innerJoin(users, eq(workspaceMembers.userId, users.id))
        .where(eq(workspaceMembers.workspaceId, input.workspaceId));
    }),
});