@tuturuuu/ui 0.37.2 → 0.39.0

package/src/components/ui/legacy/calendar/event-save-payload.test.ts

@@ -0,0 +1,40 @@
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
+import { expect, it } from 'vitest';
+import { calendarEventUpdatePayload } from '../../../../hooks/calendar-event-write-payload';
+import { eventSavePayload } from './event-save-payload';
+
+const original = {
+  id: 'saved',
+  title: 'Synthetic',
+  description: '',
+  location: '',
+  start_at: '2026-10-02T10:00:00Z',
+  end_at: '2026-10-02T11:00:00Z',
+  color: 'BLUE',
+  locked: false,
+} as CalendarEvent;
+it('sends only a provider color command for an unchanged existing event', () => {
+  const providerColor = { connectionId: 'owned', kind: 'inherit' as const };
+  const payload = eventSavePayload(
+    {
+      ...original,
+      providerColor,
+      source: { provider: 'google', connectionId: 'owned' },
+    },
+    original,
+    false
+  );
+  expect(payload).toEqual({ providerColor });
+  expect(calendarEventUpdatePayload(payload)).toEqual({ providerColor });
+});
+it('does not include unchanged native color or source with an ordinary title edit', () => {
+  expect(eventSavePayload({ ...original, title: 'Changed' }, original)).toEqual(
+    { title: 'Changed' }
+  );
+});
+it('includes a calendar transfer only when its source actually changed', () => {
+  const source = { provider: 'google' as const, connectionId: 'new' };
+  expect(eventSavePayload({ ...original, source }, original, true)).toEqual({
+    source,
+  });
+});

package/src/components/ui/legacy/calendar/event-save-payload.ts

@@ -0,0 +1,79 @@
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
+import { newCalendarCreationRequestId } from '../../../../hooks/calendar-creation-request';
+
+/** Existing edits send only changed fields so a color-only command neither
+ * broadcasts invitations nor accidentally becomes a calendar transfer. */
+export function eventSavePayload(
+  draft: Partial<CalendarEvent>,
+  original?: Partial<CalendarEvent>,
+  sourceChanged = false
+) {
+  if (!original || original.id === 'new') return draft;
+  const updates: Partial<CalendarEvent> = {};
+  for (const field of [
+    'title',
+    'description',
+    'location',
+    'start_at',
+    'end_at',
+    'locked',
+  ] as const) {
+    if (
+      (draft[field] ?? (field === 'locked' ? false : '')) !==
+      (original[field] ?? (field === 'locked' ? false : ''))
+    )
+      Object.assign(updates, { [field]: draft[field] });
+  }
+  if (draft.providerColor) updates.providerColor = draft.providerColor;
+  else if (draft.color !== original.color) updates.color = draft.color;
+  if (sourceChanged) updates.source = draft.source;
+  return updates;
+}
+
+export function eventModalSavePayload(
+  draft: Partial<CalendarEvent>,
+  original: Partial<CalendarEvent> | undefined,
+  source: CalendarEvent['source'],
+  sourceChanged: boolean
+) {
+  return eventSavePayload(
+    {
+      title: draft.title || '',
+      description: draft.description || '',
+      start_at: draft.start_at,
+      end_at: draft.end_at,
+      color: draft.color || 'BLUE',
+      location: draft.location || '',
+      locked: draft.locked || false,
+      source,
+      providerColor: draft.providerColor,
+    },
+    original,
+    sourceChanged
+  );
+}
+
+export function eventModalDraft(
+  activeEvent: CalendarEvent
+): Partial<CalendarEvent> {
+  return {
+    id: activeEvent.id,
+    requestId:
+      activeEvent.id === 'new' ? newCalendarCreationRequestId() : undefined,
+    title: activeEvent.title || '',
+    description: activeEvent.description || '',
+    start_at: activeEvent.start_at,
+    end_at: activeEvent.end_at,
+    color: activeEvent.color || 'BLUE',
+    location: activeEvent.location || '',
+    locked: activeEvent.locked || false,
+    ws_id: activeEvent.ws_id,
+    provider: activeEvent.provider,
+    source_calendar_id: activeEvent.source_calendar_id,
+    external_calendar_id: activeEvent.external_calendar_id,
+    external_event_id: activeEvent.external_event_id,
+    google_event_id: activeEvent.google_event_id,
+    google_calendar_id: activeEvent.google_calendar_id,
+    scheduling_metadata: activeEvent.scheduling_metadata,
+  };
+}

package/src/components/ui/legacy/calendar/event-source-selection.test.ts

@@ -0,0 +1,95 @@
+import type { CalendarSourceOption } from '@tuturuuu/internal-api';
+import { expect, it } from 'vitest';
+import { eventModalSavePayload } from './event-save-payload';
+import {
+  eventSourceChanged,
+  findEventSourceOption,
+  selectedEventSource,
+} from './event-source-selection';
+
+const options = ['one', 'two'].map((id) => ({
+  id,
+  provider: 'google',
+  connectionId: id,
+  workspaceCalendarId: id,
+  externalCalendarId: 'shared-provider-calendar',
+})) as CalendarSourceOption[];
+it('matches the canonical workspace source despite identical provider calendar IDs', () => {
+  expect(
+    findEventSourceOption(options, {
+      provider: 'google',
+      source_calendar_id: 'two',
+      external_calendar_id: 'shared-provider-calendar',
+    })?.id
+  ).toBe('two');
+  expect(
+    findEventSourceOption(options, {
+      provider: 'google',
+      source_calendar_id: 'missing',
+      external_calendar_id: 'shared-provider-calendar',
+    })
+  ).toBeUndefined();
+});
+it('fails closed when a legacy external calendar ID is ambiguous across accounts', () => {
+  expect(
+    findEventSourceOption(options, {
+      provider: 'google',
+      external_calendar_id: 'shared-provider-calendar',
+    })
+  ).toBeUndefined();
+  expect(
+    findEventSourceOption(options.slice(0, 1), {
+      provider: 'google',
+      external_calendar_id: 'shared-provider-calendar',
+    })?.id
+  ).toBe('one');
+});
+
+it('leaves an unresolved existing event on its original source and preserves new defaults', () => {
+  const original = {
+    id: 'saved',
+    provider: 'google' as const,
+    source_calendar_id: 'missing',
+    external_calendar_id: 'shared-provider-calendar',
+  };
+  expect(
+    selectedEventSource(options, original, null, options[0])
+  ).toBeUndefined();
+  expect(eventSourceChanged(options, original, null)).toBe(false);
+  expect(
+    selectedEventSource(options, { id: 'new' }, null, options[0])?.id
+  ).toBe('one');
+  expect(selectedEventSource(options, original, 'two', options[0])?.id).toBe(
+    'two'
+  );
+  expect(eventSourceChanged(options, original, 'two')).toBe(true);
+});
+
+it('sends only a title edit when an existing source cannot be resolved', () => {
+  const original = {
+    id: 'saved',
+    title: 'Original',
+    color: 'BLUE' as const,
+    provider: 'google' as const,
+    source_calendar_id: 'missing',
+    start_at: '2026-10-02T10:00:00Z',
+    end_at: '2026-10-02T11:00:00Z',
+  };
+  const selected = selectedEventSource(options, original, null, options[0]);
+  expect(
+    eventModalSavePayload(
+      { ...original, title: 'Changed' },
+      original,
+      selected?.provider === 'google'
+        ? { provider: 'google', connectionId: selected.connectionId }
+        : undefined,
+      eventSourceChanged(options, original, null)
+    )
+  ).toEqual({ title: 'Changed' });
+});
+
+it('recognizes a legacy Google event before considering native sources', () => {
+  const legacy = { google_event_id: 'external', source_calendar_id: 'two' };
+  expect(findEventSourceOption(options, legacy)?.id).toBe('two');
+  expect(eventSourceChanged(options, legacy, 'two')).toBe(false);
+});

package/src/components/ui/legacy/calendar/event-source-selection.ts

@@ -0,0 +1,78 @@
+import type {
+  CalendarSourceInput,
+  CalendarSourceOption,
+} from '@tuturuuu/internal-api';
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
+
+export function sourceInputFromOption(
+  option?: CalendarSourceOption | null
+): CalendarSourceInput | undefined {
+  if (!option) return undefined;
+
+  if (option.provider === 'tuturuuu') {
+    return {
+      provider: 'tuturuuu',
+      workspaceCalendarId: option.workspaceCalendarId,
+    };
+  }
+
+  return {
+    provider: option.provider,
+    connectionId: option.connectionId,
+  };
+}
+
+export function findEventSourceOption(
+  options: CalendarSourceOption[],
+  event: Partial<CalendarEvent>
+) {
+  const provider =
+    event.provider ?? (event.google_event_id ? 'google' : undefined);
+  if (provider === 'google' || provider === 'microsoft') {
+    const matches = options.filter((option) => {
+      if (option.provider === 'tuturuuu' || option.provider !== provider)
+        return false;
+      if (event.source_calendar_id)
+        return option.workspaceCalendarId === event.source_calendar_id;
+      return (
+        option.externalCalendarId ===
+        (event.external_calendar_id ?? event.google_calendar_id)
+      );
+    });
+    // Legacy rows without a canonical source must not choose another account
+    // merely because it contains the same provider calendar ID.
+    return matches.length === 1 ? matches[0] : undefined;
+  }
+
+  return options.find(
+    (option) =>
+      option.provider === 'tuturuuu' &&
+      option.workspaceCalendarId === event.source_calendar_id
+  );
+}
+
+export function selectedEventSource(
+  options: CalendarSourceOption[],
+  event: Partial<CalendarEvent>,
+  selectedId: string | null,
+  defaultSource?: CalendarSourceOption
+) {
+  const selected = options.find((option) => option.id === selectedId);
+  const existing = !!event.id && event.id !== 'new';
+  return (
+    selected ??
+    findEventSourceOption(options, event) ??
+    (existing ? undefined : (defaultSource ?? options[0]))
+  );
+}
+export function eventSourceChanged(
+  options: CalendarSourceOption[],
+  event: Partial<CalendarEvent>,
+  selectedId: string | null
+) {
+  return (
+    selectedId !== null &&
+    options.some((option) => option.id === selectedId) &&
+    selectedId !== findEventSourceOption(options, event)?.id
+  );
+}