feat:소셜 로그인 기반 워크스페이스·공지 연동(#50)

src/app/workspaces/[workspaceId]/layout.tsx

@@ -1,6 +1,7 @@
 // 워크스페이스 공통 사이드바와 헤더를 적용하는 라우트 레이아웃입니다.
 import { notFound } from 'next/navigation';
 import { getWorkspaceById } from '@/entities/workspace/api/get-workspace-by-id';
+import { getCurrentWorkspaceMember } from '@/entities/workspace-member/api/get-current-workspace-member';
 import { WorkspaceShell } from '@/widgets/workspace-shell';
 
 interface WorkspaceLayoutProps {
@@ -12,14 +13,17 @@ interface WorkspaceLayoutProps {
 
 export default async function WorkspaceLayout({ children, params }: WorkspaceLayoutProps) {
   const { workspaceId } = await params;
-  const workspace = await getWorkspaceById(workspaceId);
+  const [workspace, currentMember] = await Promise.all([
+    getWorkspaceById(workspaceId),
+    getCurrentWorkspaceMember(workspaceId),
+  ]);
 
-  if (!workspace) {
+  if (!workspace || !currentMember) {
     notFound();
   }
 
   return (
-    <WorkspaceShell workspace={workspace} workspaceId={workspaceId}>
+    <WorkspaceShell workspace={workspace} workspaceId={workspaceId} currentMember={currentMember}>
       {children}
     </WorkspaceShell>
   );

src/app/workspaces/[workspaceId]/notices/page.tsx

@@ -1,4 +1,5 @@
 // 워크스페이스 공지 페이지의 라우트 진입점입니다.
+import { getNoticeBoard } from '@/entities/notice/api/get-notice-board';
 import { NoticesView } from '@/views/store-operation/notices';
 
 interface NoticesPageProps {
@@ -9,6 +10,7 @@ interface NoticesPageProps {
 
 export default async function NoticesPage({ params }: NoticesPageProps) {
   const { workspaceId } = await params;
+  const initialData = await getNoticeBoard(workspaceId);
 
-  return <NoticesView workspaceId={workspaceId} />;
+  return <NoticesView workspaceId={workspaceId} initialData={initialData} />;
 }

src/app/workspaces/[workspaceId]/page.tsx

@@ -16,10 +16,10 @@ export default async function WorkspaceHomePage({ params }: WorkspaceHomePagePro
   }
 
   if (workspace.purpose === 'store-operation') {
-    redirect(`/workspaces/${workspaceId}/work-schedule`);
+    redirect(`/workspaces/${workspaceId}/dashboard`);
   }
   if (workspace.purpose === 'side-project') {
-    redirect(`/workspaces/${workspaceId}/sprint-board`);
+    redirect(`/workspaces/${workspaceId}/dashboard`);
   }
 
   redirect(`/workspaces/${workspaceId}/project-management`);

src/entities/notice/api/get-notice-board.ts

@@ -0,0 +1,84 @@
+'use server';
+
+// 워크스페이스 공지와 현재 사용자의 역할을 함께 조회해 공지 화면·위젯의 데이터 기준을 통일합니다.
+import { z } from 'zod';
+import { getCurrentUserId } from '@/shared/api/supabase/current-user';
+import { createSupabaseServerClient } from '@/shared/api/supabase/server';
+import type { Notice, NoticeBoardData } from '../model/notice.types';
+
+const workspaceIdSchema = z.guid();
+
+function toCreatedAtLabel(value: string): string {
+  return value.slice(0, 10);
+}
+
+export async function getNoticeBoard(workspaceId: string): Promise<NoticeBoardData> {
+  const parsedWorkspaceId = workspaceIdSchema.parse(workspaceId);
+  const supabase = await createSupabaseServerClient();
+  const currentUserId = await getCurrentUserId();
+
+  const [
+    { data: announcements, error: announcementError },
+    { data: membership, error: memberError },
+  ] = await Promise.all([
+    supabase
+      .from('announcements')
+      .select('id, workspace_id, author_id, title, content, is_pinned, created_at')
+      .eq('workspace_id', parsedWorkspaceId)
+      .order('is_pinned', { ascending: false })
+      .order('created_at', { ascending: false }),
+    supabase
+      .from('workspace_members')
+      .select('user_id, role')
+      .eq('workspace_id', parsedWorkspaceId)
+      .eq('user_id', currentUserId)
+      .maybeSingle(),
+  ]);
+
+  if (announcementError) {
+    throw new Error(`공지 조회에 실패했습니다: ${announcementError.message}`);
+  }
+
+  if (memberError) {
+    throw new Error(`현재 멤버 조회에 실패했습니다: ${memberError.message}`);
+  }
+
+  const authorIds = [
+    ...new Set(
+      (announcements ?? []).flatMap((notice) => (notice.author_id ? [notice.author_id] : [])),
+    ),
+  ];
+  const { data: profiles, error: profileError } = authorIds.length
+    ? await supabase.from('profiles').select('id, real_name').in('id', authorIds)
+    : { data: [], error: null };
+
+  if (profileError) {
+    throw new Error(`공지 작성자 조회에 실패했습니다: ${profileError.message}`);
+  }
+
+  const profileNameById = new Map(
+    (profiles ?? []).map((profile) => [profile.id, profile.real_name]),
+  );
+  const notices: Notice[] = (announcements ?? []).map((notice) => ({
+    id: notice.id,
+    workspaceId: notice.workspace_id,
+    authorId: notice.author_id,
+    title: notice.title,
+    content: notice.content,
+    authorName: notice.author_id
+      ? (profileNameById.get(notice.author_id) ?? '알 수 없음')
+      : '탈퇴한 사용자',
+    createdAt: toCreatedAtLabel(notice.created_at),
+    isPinned: notice.is_pinned,
+  }));
+
+  return {
+    notices,
+    viewer: membership
+      ? {
+          userId: membership.user_id,
+          role: membership.role,
+        }
+      : null,
+  };
+}

src/entities/notice/api/notice-actions.ts

@@ -0,0 +1,208 @@
+'use server';
+
+// 공지 작성·수정·삭제·고정 변경을 입력 검증과 워크스페이스 권한 확인 후 처리합니다.
+import { revalidatePath } from 'next/cache';
+import { z } from 'zod';
+import { getCurrentUserId } from '@/shared/api/supabase/current-user';
+import { createSupabaseServerClient } from '@/shared/api/supabase/server';
+
+const uuidSchema = z.guid();
+const noticeContentSchema = z.object({
+  title: z.string().trim().min(1, '공지 제목을 입력해주세요.').max(120),
+  content: z.string().trim().min(1, '공지 내용을 입력해주세요.').max(10_000),
+});
+
+type WorkspaceMember = { user_id: string; role: 'owner' | 'member' };
+
+export type NoticeActionResult<T> = { ok: true; data: T } | { ok: false; message: string };
+
+class NoticeActionError extends Error {}
+
+function throwNoticeActionError(message: string): never {
+  throw new NoticeActionError(message);
+}
+
+function toActionFailure(error: unknown, fallbackMessage: string): NoticeActionResult<never> {
+  if (error instanceof NoticeActionError) {
+    return { ok: false, message: error.message };
+  }
+
+  console.error('[notice action] 예상하지 못한 오류:', error);
+  return { ok: false, message: fallbackMessage };
+}
+
+function revalidateNoticePages(workspaceId: string): void {
+  revalidatePath(`/workspaces/${workspaceId}/notices`);
+  revalidatePath(`/workspaces/${workspaceId}/dashboard`);
+}
+
+async function getCurrentWorkspaceMember(workspaceId: string): Promise<{
+  supabase: Awaited<ReturnType<typeof createSupabaseServerClient>>;
+  member: WorkspaceMember;
+}> {
+  const supabase = await createSupabaseServerClient();
+  const currentUserId = await getCurrentUserId();
+  const { data, error } = await supabase
+    .from('workspace_members')
+    .select('user_id, role')
+    .eq('workspace_id', workspaceId)
+    .eq('user_id', currentUserId)
+    .maybeSingle();
+
+  if (error) {
+    console.error('[notice action] 워크스페이스 멤버 확인 실패:', error);
+    throwNoticeActionError('워크스페이스 멤버 정보를 확인하지 못했습니다.');
+  }
+
+  if (!data) {
+    throwNoticeActionError('워크스페이스 멤버만 공지를 관리할 수 있습니다.');
+  }
+
+  return { supabase, member: data };
+}
+
+async function getEditableAnnouncement(input: { workspaceId: string; noticeId: string }) {
+  const { supabase, member } = await getCurrentWorkspaceMember(input.workspaceId);
+  const { data: notice, error } = await supabase
+    .from('announcements')
+    .select('id, author_id')
+    .eq('id', input.noticeId)
+    .eq('workspace_id', input.workspaceId)
+    .maybeSingle();
+
+  if (error) {
+    console.error('[notice action] 공지 조회 실패:', error);
+    throwNoticeActionError('공지 정보를 확인하지 못했습니다.');
+  }
+
+  if (!notice) {
+    throwNoticeActionError('공지를 찾을 수 없습니다.');
+  }
+
+  if (member.role !== 'owner' && notice.author_id !== member.user_id) {
+    throwNoticeActionError(
+      '작성자 또는 워크스페이스 소유자만 공지를 수정하거나 삭제할 수 있습니다.',
+    );
+  }
+
+  return { supabase, member, notice };
+}
+
+export async function createNotice(input: {
+  workspaceId: string;
+  title: string;
+  content: string;
+}): Promise<NoticeActionResult<{ id: string }>> {
+  try {
+    const value = z.object({ workspaceId: uuidSchema }).merge(noticeContentSchema).parse(input);
+    const { supabase, member } = await getCurrentWorkspaceMember(value.workspaceId);
+    const { data, error } = await supabase
+      .from('announcements')
+      .insert({
+        workspace_id: value.workspaceId,
+        author_id: member.user_id,
+        title: value.title,
+        content: value.content,
+      })
+      .select('id')
+      .single();
+
+    if (error) {
+      console.error('[notice action] 공지 등록 실패:', error);
+      throwNoticeActionError('공지 등록에 실패했습니다. 잠시 후 다시 시도해주세요.');
+    }
+
+    revalidateNoticePages(value.workspaceId);
+    return { ok: true, data: { id: data.id } };
+  } catch (error) {
+    return toActionFailure(error, '공지 등록에 실패했습니다. 입력값을 확인해주세요.');
+  }
+}
+
+export async function updateNotice(input: {
+  workspaceId: string;
+  noticeId: string;
+  title: string;
+  content: string;
+}): Promise<NoticeActionResult<void>> {
+  try {
+    const value = z
+      .object({ workspaceId: uuidSchema, noticeId: uuidSchema })
+      .merge(noticeContentSchema)
+      .parse(input);
+    const { supabase } = await getEditableAnnouncement(value);
+    const { error } = await supabase
+      .from('announcements')
+      .update({ title: value.title, content: value.content })
+      .eq('id', value.noticeId)
+      .eq('workspace_id', value.workspaceId);
+
+    if (error) {
+      console.error('[notice action] 공지 수정 실패:', error);
+      throwNoticeActionError('공지 수정에 실패했습니다. 잠시 후 다시 시도해주세요.');
+    }
+
+    revalidateNoticePages(value.workspaceId);
+    return { ok: true, data: undefined };
+  } catch (error) {
+    return toActionFailure(error, '공지 수정에 실패했습니다. 입력값을 확인해주세요.');
+  }
+}
+
+export async function deleteNotice(input: {
+  workspaceId: string;
+  noticeId: string;
+}): Promise<NoticeActionResult<void>> {
+  try {
+    const value = z.object({ workspaceId: uuidSchema, noticeId: uuidSchema }).parse(input);
+    const { supabase } = await getEditableAnnouncement(value);
+    const { error } = await supabase
+      .from('announcements')
+      .delete()
+      .eq('id', value.noticeId)
+      .eq('workspace_id', value.workspaceId);
+
+    if (error) {
+      console.error('[notice action] 공지 삭제 실패:', error);
+      throwNoticeActionError('공지 삭제에 실패했습니다. 잠시 후 다시 시도해주세요.');
+    }
+
+    revalidateNoticePages(value.workspaceId);
+    return { ok: true, data: undefined };
+  } catch (error) {
+    return toActionFailure(error, '공지 삭제에 실패했습니다. 잠시 후 다시 시도해주세요.');
+  }
+}
+
+export async function setNoticePinned(input: {
+  workspaceId: string;
+  noticeId: string;
+  isPinned: boolean;
+}): Promise<NoticeActionResult<void>> {
+  try {
+    const value = z
+      .object({ workspaceId: uuidSchema, noticeId: uuidSchema, isPinned: z.boolean() })
+      .parse(input);
+    const { supabase, member } = await getCurrentWorkspaceMember(value.workspaceId);
+
+    if (member.role !== 'owner') {
+      throwNoticeActionError('워크스페이스 소유자만 공지를 고정할 수 있습니다.');
+    }
+
+    const { error } = await supabase
+      .from('announcements')
+      .update({ is_pinned: value.isPinned })
+      .eq('id', value.noticeId)
+      .eq('workspace_id', value.workspaceId);
+
+    if (error) {
+      console.error('[notice action] 공지 고정 상태 변경 실패:', error);
+      throwNoticeActionError('공지 고정 상태 변경에 실패했습니다. 잠시 후 다시 시도해주세요.');
+    }
+
+    revalidateNoticePages(value.workspaceId);
+    return { ok: true, data: undefined };
+  } catch (error) {
+    return toActionFailure(error, '공지 고정 상태 변경에 실패했습니다. 잠시 후 다시 시도해주세요.');
+  }
+}

src/entities/notice/index.ts

@@ -1,3 +1,2 @@
-// 공지 도메인의 타입과 목업 데이터 공개 API입니다.
-export type { Notice, NoticeFormValues } from './model/notice.types';
-export { mockNotices } from './model/mock-notices';
+// 공지 도메인이 외부 레이어에 제공하는 타입 공개 API입니다.
+export type { Notice, NoticeBoardData, NoticeFormValues, NoticeViewer } from './model/notice.types';