@tuturuuu/ui 0.1.0 → 0.3.1

package/src/components/ui/legacy/calendar/smart-calendar.test.tsx

@@ -0,0 +1,76 @@
+// @vitest-environment jsdom
+
+import { render, screen } from '@testing-library/react';
+import type { Workspace } from '@tuturuuu/types';
+import type { ReactNode } from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { SmartCalendar } from './smart-calendar';
+
+vi.mock('@tuturuuu/ui/hooks/use-calendar', () => ({
+  CalendarProvider: ({ children }: { children: ReactNode }) => (
+    <div data-testid="calendar-provider">{children}</div>
+  ),
+}));
+
+vi.mock('./settings/settings-context', () => ({
+  CalendarSettingsProvider: ({ children }: { children: ReactNode }) => (
+    <div data-testid="settings-provider">{children}</div>
+  ),
+}));
+
+vi.mock('./calendar-content', () => ({
+  CalendarContent: ({ extras }: { extras?: ReactNode }) => (
+    <div data-testid="calendar-content">
+      <div data-testid="header-extras">{extras}</div>
+    </div>
+  ),
+}));
+
+vi.mock('../../calendar-app/components/calendar-connections-unified', () => ({
+  default: ({ wsId }: { wsId: string }) => (
+    <span data-testid="connections-manager">{wsId}</span>
+  ),
+}));
+
+const baseProps = {
+  locale: 'en',
+  t: (key: string) => key,
+  useQuery: vi.fn(),
+  useQueryClient: vi.fn(),
+};
+
+describe('SmartCalendar', () => {
+  it('renders the compact connections manager before existing header extras', () => {
+    render(
+      <SmartCalendar
+        {...baseProps}
+        workspace={{ id: 'workspace-1' } as Workspace}
+        extras={<span data-testid="custom-extra">extra</span>}
+      />
+    );
+
+    expect(screen.getByTestId('connections-manager').textContent).toBe(
+      'workspace-1'
+    );
+    expect(
+      Array.from(screen.getByTestId('header-extras').children).map((element) =>
+        element.getAttribute('data-testid')
+      )
+    ).toEqual(['connections-manager', 'custom-extra']);
+  });
+
+  it('keeps existing header extras when the manager is disabled', () => {
+    render(
+      <SmartCalendar
+        {...baseProps}
+        workspace={{ id: 'workspace-1' } as Workspace}
+        disabled
+        showConnectionsManager={false}
+        extras={<span data-testid="custom-extra">extra</span>}
+      />
+    );
+
+    expect(screen.queryByTestId('connections-manager')).toBeNull();
+    expect(screen.getByTestId('custom-extra').textContent).toBe('extra');
+  });
+});

package/src/components/ui/legacy/calendar/smart-calendar.tsx

@@ -6,6 +6,7 @@ import type {
 } from '@tuturuuu/types';
 import { CalendarProvider } from '@tuturuuu/ui/hooks/use-calendar';
 import type { CalendarView } from '../../../../hooks/use-view-transition';
+import CalendarConnectionsUnified from '../../calendar-app/components/calendar-connections-unified';
 import { CalendarContent } from './calendar-content';
 import {
   type CalendarSettings,
@@ -26,6 +27,7 @@ export const SmartCalendar = ({
   overlay,
   initialSettings,
   onSaveSettings,
+  showConnectionsManager = true,
 }: {
   t: any;
   locale: string;
@@ -46,12 +48,22 @@ export const SmartCalendar = ({
   overlay?: React.ReactNode;
   initialSettings?: Partial<CalendarSettings>;
   onSaveSettings?: (settings: CalendarSettings) => Promise<void>;
+  showConnectionsManager?: boolean;
 }) => {
   const handleSaveSettings = async (newSettings: CalendarSettings) => {
     if (onSaveSettings) {
       await onSaveSettings(newSettings);
     }
   };
+  const headerExtras =
+    showConnectionsManager && workspace?.id ? (
+      <>
+        <CalendarConnectionsUnified wsId={workspace.id} />
+        {extras}
+      </>
+    ) : (
+      extras
+    );
 
   return (
     <CalendarProvider
@@ -73,7 +85,7 @@ export const SmartCalendar = ({
           enableHeader={enableHeader}
           experimentalGoogleToken={experimentalGoogleToken}
           externalState={externalState}
-          extras={extras}
+          extras={headerExtras}
           overlay={overlay}
         />
       </CalendarSettingsProvider>

package/src/components/ui/legacy/meet/page.test.ts

@@ -0,0 +1,180 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getMeetTogetherPlansData } from './page';
+
+const mocks = vi.hoisted(() => ({
+  createAdminClient: vi.fn(),
+  createClient: vi.fn(),
+}));
+
+vi.mock('@tuturuuu/supabase/next/server', () => ({
+  createAdminClient: (...args: Parameters<typeof mocks.createAdminClient>) =>
+    mocks.createAdminClient(...args),
+  createClient: (...args: Parameters<typeof mocks.createClient>) =>
+    mocks.createClient(...args),
+}));
+
+vi.mock('next-intl/server', () => ({
+  getLocale: vi.fn().mockResolvedValue('en'),
+  getTranslations: vi.fn().mockResolvedValue((key: string) => key),
+}));
+
+type QueryCall = {
+  column?: string;
+  table: string;
+  type: 'select' | 'eq' | 'neq' | 'order' | 'in';
+  value?: unknown;
+};
+
+function createBuilder(table: string, data: unknown[], calls: QueryCall[]) {
+  const builder = Object.assign(Promise.resolve({ data, error: null }), {
+    eq: vi.fn((column: string, value: unknown) => {
+      calls.push({ column, table, type: 'eq', value });
+      return builder;
+    }),
+    in: vi.fn((column: string, value: unknown) => {
+      calls.push({ column, table, type: 'in', value });
+      return builder;
+    }),
+    neq: vi.fn((column: string, value: unknown) => {
+      calls.push({ column, table, type: 'neq', value });
+      return builder;
+    }),
+    order: vi.fn((column: string, value: unknown) => {
+      calls.push({ column, table, type: 'order', value });
+      return builder;
+    }),
+    select: vi.fn((column: string) => {
+      calls.push({ column, table, type: 'select' });
+      return builder;
+    }),
+  });
+
+  return builder;
+}
+
+describe('MeetTogether plans data', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.createClient.mockResolvedValue({
+      auth: {
+        getUser: vi.fn().mockResolvedValue({
+          data: { user: { id: 'user-1' } },
+        }),
+      },
+    });
+  });
+
+  it('consolidates personal workspace plans with previously interacted plans', async () => {
+    const calls: QueryCall[] = [];
+    const personalPlan = {
+      created_at: '2026-01-01T00:00:00.000Z',
+      creator_id: 'user-1',
+      id: 'personal-created',
+      ws_id: 'personal-ws',
+    };
+    const interactedPlan = {
+      created_at: '2026-01-03T00:00:00.000Z',
+      creator_id: 'other-user',
+      id: 'team-interacted',
+      ws_id: 'team-ws',
+    };
+    const participant = {
+      display_name: 'User',
+      is_guest: false,
+      plan_id: 'team-interacted',
+      timeblock_count: 1,
+      user_id: 'user-1',
+    };
+    const builders = [
+      createBuilder('meet_together_plans', [personalPlan], calls),
+      createBuilder(
+        'meet_together_user_timeblocks',
+        [interactedPlan, personalPlan],
+        calls
+      ),
+      createBuilder('meet_together_users', [participant], calls),
+    ];
+
+    mocks.createAdminClient.mockResolvedValue({
+      from: vi.fn(() => builders.shift()),
+    });
+
+    const result = await getMeetTogetherPlansData({
+      scope: 'personal-consolidated',
+      wsId: 'personal-ws',
+    });
+
+    expect(result.data.map((plan) => plan.id)).toEqual([
+      'team-interacted',
+      'personal-created',
+    ]);
+    expect(result.totalCount).toBe(2);
+    expect(result.data[0]?.participants).toEqual([participant]);
+    expect(calls).toEqual(
+      expect.arrayContaining([
+        {
+          column: 'ws_id',
+          table: 'meet_together_plans',
+          type: 'eq',
+          value: 'personal-ws',
+        },
+        {
+          column: 'user_id',
+          table: 'meet_together_user_timeblocks',
+          type: 'eq',
+          value: 'user-1',
+        },
+      ])
+    );
+    expect(calls).not.toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          column: 'meet_together_plans.ws_id',
+          table: 'meet_together_user_timeblocks',
+          type: 'eq',
+        }),
+      ])
+    );
+  });
+
+  it('keeps team workspace plans scoped to the active workspace', async () => {
+    const calls: QueryCall[] = [];
+    const builders = [
+      createBuilder('meet_together_plans', [], calls),
+      createBuilder('meet_together_user_timeblocks', [], calls),
+      createBuilder('meet_together_users', [], calls),
+    ];
+
+    mocks.createAdminClient.mockResolvedValue({
+      from: vi.fn(() => builders.shift()),
+    });
+
+    await getMeetTogetherPlansData({
+      scope: 'workspace',
+      wsId: 'team-ws',
+    });
+
+    expect(calls).toEqual(
+      expect.arrayContaining([
+        {
+          column: 'ws_id',
+          table: 'meet_together_plans',
+          type: 'eq',
+          value: 'team-ws',
+        },
+        {
+          column: 'meet_together_plans.ws_id',
+          table: 'meet_together_user_timeblocks',
+          type: 'eq',
+          value: 'team-ws',
+        },
+        {
+          column: 'meet_together_plans.creator_id',
+          table: 'meet_together_user_timeblocks',
+          type: 'neq',
+          value: 'user-1',
+        },
+      ])
+    );
+  });
+});

package/src/components/ui/legacy/meet/page.tsx

@@ -27,8 +27,18 @@ export interface MeetTogetherPlanWithParticipants extends MeetTogetherPlan {
   }>;
 }
 
+type MeetTogetherPlanRow = Record<string, unknown> & {
+  created_at?: string | null;
+  creator_id?: string | null;
+  description?: string | null;
+  id?: string | null;
+  name?: string | null;
+  ws_id?: string | null;
+};
+
 // Server component props type
 interface MeetTogetherPageProps {
+  scope?: MeetTogetherPlansScope;
   wsId?: string;
   path?: string;
   searchParams?: Promise<{
@@ -38,7 +48,10 @@ interface MeetTogetherPageProps {
   }>;
 }
 
+export type MeetTogetherPlansScope = 'workspace' | 'personal-consolidated';
+
 export async function MeetTogetherPage({
+  scope = 'workspace',
   wsId,
   path,
   searchParams,
@@ -55,7 +68,7 @@ export async function MeetTogetherPage({
     data: plans,
     user,
     totalCount,
-  } = await getData({ wsId, page, pageSize });
+  } = await getMeetTogetherPlansData({ scope, wsId, page, pageSize });
   const totalPages = Math.ceil(totalCount / pageSize);
 
   return (
@@ -222,11 +235,13 @@ export async function MeetTogetherPage({
   );
 }
 
-async function getData({
+export async function getMeetTogetherPlansData({
+  scope = 'workspace',
   wsId,
   page = 1,
   pageSize = 9,
 }: {
+  scope?: MeetTogetherPlansScope;
   wsId?: string;
   page?: number;
   pageSize?: number;
@@ -241,47 +256,80 @@ async function getData({
 
   const sbAdmin = await createAdminClient();
 
-  const createdPlansQuery = sbAdmin
-    .from('meet_together_plans')
-    .select('*')
-    .eq('creator_id', user.id)
-    .order('created_at', { ascending: false });
-
-  const joinedPlansQuery = sbAdmin
-    .from('meet_together_user_timeblocks')
-    .select('...meet_together_plans!inner(*)')
-    .eq('user_id', user.id)
-    .neq('meet_together_plans.creator_id', user.id)
-    .order('created_at', {
-      ascending: false,
-      referencedTable: 'meet_together_plans',
+  const planMap = new Map<string, MeetTogetherPlan>();
+  const addPlans = (plans: MeetTogetherPlanRow[] | null | undefined) => {
+    plans?.forEach((plan) => {
+      const planId = plan.id ?? undefined;
+
+      if (planId && !planMap.has(planId)) {
+        planMap.set(planId, {
+          ...plan,
+          agenda_content: plan.agenda_content ?? undefined,
+          created_at: plan.created_at ?? undefined,
+          creator_id: plan.creator_id ?? undefined,
+          description: plan.description ?? undefined,
+          id: planId,
+          name: plan.name ?? undefined,
+          ws_id: plan.ws_id ?? undefined,
+        } as MeetTogetherPlan);
+      }
     });
+  };
 
-  if (wsId) {
-    createdPlansQuery.eq('ws_id', wsId);
-    joinedPlansQuery.eq('meet_together_plans.ws_id', wsId);
-  }
-
-  const [createdPlansResult, joinedPlansResult] = await Promise.all([
-    createdPlansQuery,
-    joinedPlansQuery,
-  ]);
+  if (scope === 'personal-consolidated' && wsId) {
+    const personalPlansQuery = sbAdmin
+      .from('meet_together_plans')
+      .select('*')
+      .eq('creator_id', user.id)
+      .eq('ws_id', wsId)
+      .order('created_at', { ascending: false });
+
+    const interactedPlansQuery = sbAdmin
+      .from('meet_together_user_timeblocks')
+      .select('...meet_together_plans!inner(*)')
+      .eq('user_id', user.id)
+      .order('created_at', {
+        ascending: false,
+        referencedTable: 'meet_together_plans',
+      });
+
+    const [personalPlansResult, interactedPlansResult] = await Promise.all([
+      personalPlansQuery,
+      interactedPlansQuery,
+    ]);
+
+    addPlans(personalPlansResult.data);
+    addPlans(interactedPlansResult.data);
+  } else {
+    const createdPlansQuery = sbAdmin
+      .from('meet_together_plans')
+      .select('*')
+      .eq('creator_id', user.id)
+      .order('created_at', { ascending: false });
+
+    const joinedPlansQuery = sbAdmin
+      .from('meet_together_user_timeblocks')
+      .select('...meet_together_plans!inner(*)')
+      .eq('user_id', user.id)
+      .neq('meet_together_plans.creator_id', user.id)
+      .order('created_at', {
+        ascending: false,
+        referencedTable: 'meet_together_plans',
+      });
+
+    if (wsId) {
+      createdPlansQuery.eq('ws_id', wsId);
+      joinedPlansQuery.eq('meet_together_plans.ws_id', wsId);
+    }
 
-  const { data: createdPlans } = createdPlansResult;
-  const { data: joinedPlans } = joinedPlansResult;
+    const [createdPlansResult, joinedPlansResult] = await Promise.all([
+      createdPlansQuery,
+      joinedPlansQuery,
+    ]);
 
-  // Combine and deduplicate
-  const planMap = new Map();
-  createdPlans?.forEach((plan) => {
-    if (!planMap.has(plan.id)) {
-      planMap.set(plan.id, plan);
-    }
-  });
-  joinedPlans?.forEach((plan) => {
-    if (!planMap.has(plan.id)) {
-      planMap.set(plan.id, plan);
-    }
-  });
+    addPlans(createdPlansResult.data);
+    addPlans(joinedPlansResult.data);
+  }
 
   const allPlans = Array.from(planMap.values()).sort(
     (a, b) =>

package/src/components/ui/legacy/meet/planId/page.tsx

@@ -17,23 +17,29 @@ interface Props {
   params: Promise<{
     planId: string;
   }>;
+  actorUserId?: string | null;
   baseUrl: string;
 }
 
 export default async function MeetTogetherPlanDetailsPage({
+  actorUserId,
   params,
   baseUrl,
 }: Props) {
   const { planId } = await params;
 
   const platformUser = await getCurrentUser();
-  const plan = await getPlan(planId);
-  const users: PlanUser[] = await getUsers(planId);
-  const polls = await getPollsForPlan(planId);
-  const timeblocks = await getTimeBlocks(planId);
+  const plan = await getPlan(planId, { actorUserId });
 
   if (!plan) return notFound();
 
+  const canonicalPlanId = plan.id;
+  if (!canonicalPlanId) return notFound();
+
+  const users: PlanUser[] = await getUsers(canonicalPlanId);
+  const polls = await getPollsForPlan(canonicalPlanId);
+  const timeblocks = await getTimeBlocks(canonicalPlanId);
+
   return (
     <div className="flex min-h-screen w-full flex-col items-center">
       <Suspense fallback={null}>