Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

Add past event warning when inviting guests to finished events (#5904)

Jacob Beckerman145e92ca6da1
diff --git a/apps/web/src/features/block-calendar/components/EventComposerSplit.tsx b/apps/web/src/features/block-calendar/components/EventComposerSplit.tsx
index b2624ce209..0c16b620a4 100644
--- a/apps/web/src/features/block-calendar/components/EventComposerSplit.tsx
+++ b/apps/web/src/features/block-calendar/components/EventComposerSplit.tsx
@@ -28,17 +28,18 @@ export function EventComposerSplit(props: {
close();
},
});
+ const isEdit = () => props.event !== undefined;
+
const controller = createCalendarEventFormController({
initialValue:
editor.initialValues() ??
props.initialValues ??
defaultEditorInitialValues(),
+ isEdit: isEdit(),
calendarOptions: editor.calendarOptions,
guestOptions: editor.guestOptions,
});
- const isEdit = () => props.event !== undefined;
-
onMount(() =>
panel.handle.setDisplayName(isEdit() ? 'Edit event' : 'New event')
);
diff --git a/apps/web/src/features/calendar/components/composer/EventForm.tsx b/apps/web/src/features/calendar/components/composer/EventForm.tsx
index 3be34ce373..0c85166083 100644
--- a/apps/web/src/features/calendar/components/composer/EventForm.tsx
+++ b/apps/web/src/features/calendar/components/composer/EventForm.tsx
@@ -37,12 +37,21 @@ export function EventForm(props: EventFormProps) {
const formId = createUniqueId();
const dateRangeErrorId = `event-composer-date-range-error-${formId}`;
+ const pastEventWarningId = `event-composer-past-event-warning-${formId}`;
const controller = props.controller;
const state = controller.state;
const isEdit = () => props.isEdit ?? false;
const formIsDisabled = () => props.pending || props.disabled === true;
+ // An invalid range already speaks for itself; only one line shows at a time.
+ const pastEventWarning = () =>
+ controller.dateRangeError() ? undefined : controller.pastEventWarning();
+ const dateRangeDescribedBy = () => {
+ if (controller.dateRangeError()) return dateRangeErrorId;
+ return pastEventWarning() ? pastEventWarningId : undefined;
+ };
+
const fieldIsReadOnly = (field: keyof EventEditorDisabledFields) =>
props.disabledFields?.[field] === true;
const fieldIsDisabled = (field: keyof EventEditorDisabledFields) =>
@@ -86,9 +95,7 @@ export function EventForm(props: EventFormProps) {
endDisabled={fieldIsDisabled('end')}
allDayDisabled={fieldIsDisabled('allDay')}
invalid={controller.dateRangeError() !== undefined}
- describedBy={
- controller.dateRangeError() ? dateRangeErrorId : undefined
- }
+ describedBy={dateRangeDescribedBy()}
/>
<Show when={controller.dateRangeError()}>
{(error) => (
@@ -101,6 +108,17 @@ export function EventForm(props: EventFormProps) {
</p>
)}
</Show>
+ <Show when={pastEventWarning()}>
+ {(warning) => (
+ <p
+ id={pastEventWarningId}
+ role="status"
+ class="text-xs text-warning"
+ >
+ {warning()}
+ </p>
+ )}
+ </Show>
</div>
<input
diff --git a/apps/web/src/features/calendar/components/composer/create-calendar-event-form-controller.test.ts b/apps/web/src/features/calendar/components/composer/create-calendar-event-form-controller.test.ts
new file mode 100644
index 0000000000..33cadb300a
--- /dev/null
+++ b/apps/web/src/features/calendar/components/composer/create-calendar-event-form-controller.test.ts
@@ -0,0 +1,152 @@
+import { format } from 'date-fns';
+import { createRoot } from 'solid-js';
+import { afterEach, describe, expect, it } from 'vitest';
+import {
+ type CreateCalendarEventFormControllerOptions,
+ createCalendarEventFormController,
+} from './create-calendar-event-form-controller';
+import {
+ defaultEditorInitialValues,
+ type EventEditorInitialValues,
+ PAST_EVENT_GUESTS_WARNING,
+ type SelectedEventEditorGuest,
+} from './event-form-model';
+
+const DATETIME_VALUE = "yyyy-MM-dd'T'HH:mm";
+const HOUR_MS = 60 * 60 * 1000;
+
+/** A timed range offset from now, in hours, running for one hour. */
+function timedRange(startHoursFromNow: number) {
+ const start = new Date(Date.now() + startHoursFromNow * HOUR_MS);
+ return {
+ start: format(start, DATETIME_VALUE),
+ end: format(new Date(start.getTime() + HOUR_MS), DATETIME_VALUE),
+ };
+}
+
+function guest(email: string): SelectedEventEditorGuest {
+ return {
+ kind: 'custom',
+ id: `macro|${email}`,
+ data: { id: `macro|${email}`, email, invalid: false },
+ };
+}
+
+const disposers: (() => void)[] = [];
+
+afterEach(() => {
+ for (const dispose of disposers.splice(0)) dispose();
+});
+
+/**
+ * Builds a controller outside any batch, so later edits reach its memos the way
+ * a user's edits do.
+ */
+function controllerFor(
+ initialValue: Partial<EventEditorInitialValues>,
+ options?: Pick<CreateCalendarEventFormControllerOptions, 'isEdit'>
+) {
+ return createRoot((dispose) => {
+ disposers.push(dispose);
+ return createCalendarEventFormController({
+ initialValue: { ...defaultEditorInitialValues(), ...initialValue },
+ calendarOptions: () => [
+ { id: 'calendar-1', label: 'Calendar', color: '#000000' },
+ ],
+ guestOptions: () => [],
+ ...options,
+ });
+ });
+}
+
+describe('pastEventWarning', () => {
+ it('warns when a new event with guests already ended', () => {
+ const controller = controllerFor({
+ ...timedRange(-3),
+ title: 'Retro',
+ guests: '[email protected]',
+ });
+ expect(controller.pastEventWarning()).toBe(PAST_EVENT_GUESTS_WARNING);
+ });
+
+ it('warns once a guest is added to a past event', () => {
+ const controller = controllerFor(timedRange(-3));
+ expect(controller.pastEventWarning()).toBeUndefined();
+
+ controller.setSelectedGuests([guest('[email protected]')]);
+ expect(controller.pastEventWarning()).toBe(PAST_EVENT_GUESTS_WARNING);
+ });
+
+ it('stays quiet for an upcoming event with guests', () => {
+ const controller = controllerFor({
+ ...timedRange(3),
+ guests: '[email protected]',
+ });
+ expect(controller.pastEventWarning()).toBeUndefined();
+ });
+
+ it('stays quiet for a past event nobody is invited to', () => {
+ expect(controllerFor(timedRange(-3)).pastEventWarning()).toBeUndefined();
+ });
+
+ it('stays quiet while the event is still running', () => {
+ const controller = controllerFor({
+ start: format(new Date(Date.now() - HOUR_MS / 2), DATETIME_VALUE),
+ end: format(new Date(Date.now() + HOUR_MS), DATETIME_VALUE),
+ guests: '[email protected]',
+ });
+ expect(controller.pastEventWarning()).toBeUndefined();
+ });
+
+ it('stays quiet when a finished event is edited without re-inviting', () => {
+ const controller = controllerFor(
+ { ...timedRange(-3), guests: '[email protected]' },
+ { isEdit: true }
+ );
+ controller.setField('title', 'Retro notes');
+ expect(controller.pastEventWarning()).toBeUndefined();
+ });
+
+ it('warns when a guest joins a finished event that is being edited', () => {
+ const controller = controllerFor(
+ { ...timedRange(-3), guests: '[email protected]' },
+ { isEdit: true }
+ );
+ controller.setSelectedGuests([
+ guest('[email protected]'),
+ guest('[email protected]'),
+ ]);
+ expect(controller.pastEventWarning()).toBe(PAST_EVENT_GUESTS_WARNING);
+ });
+
+ it('warns when an event with guests is moved into the past', () => {
+ const controller = controllerFor(
+ { ...timedRange(3), guests: '[email protected]' },
+ { isEdit: true }
+ );
+ const past = timedRange(-3);
+ controller.setStart(past.start);
+ controller.setField('end', past.end);
+ expect(controller.pastEventWarning()).toBe(PAST_EVENT_GUESTS_WARNING);
+ });
+
+ it('warns for an all-day event on a day that has passed', () => {
+ const yesterday = format(new Date(Date.now() - 24 * HOUR_MS), 'yyyy-MM-dd');
+ const today = format(new Date(), 'yyyy-MM-dd');
+ const past = controllerFor({
+ allDay: true,
+ start: yesterday,
+ end: yesterday,
+ guests: '[email protected]',
+ });
+ expect(past.pastEventWarning()).toBe(PAST_EVENT_GUESTS_WARNING);
+
+ const ongoing = controllerFor({
+ allDay: true,
+ start: today,
+ end: today,
+ guests: '[email protected]',
+ });
+ expect(ongoing.pastEventWarning()).toBeUndefined();
+ });
+});
diff --git a/apps/web/src/features/calendar/components/composer/create-calendar-event-form-controller.ts b/apps/web/src/features/calendar/components/composer/create-calendar-event-form-controller.ts
index 7f556a70ee..569f13d162 100644
--- a/apps/web/src/features/calendar/components/composer/create-calendar-event-form-controller.ts
+++ b/apps/web/src/features/calendar/components/composer/create-calendar-event-form-controller.ts
@@ -18,9 +18,11 @@ import {
type EventEditorGuestOption,
type EventEditorInitialValues,
type EventEditorSubmitValues,
+ eventHasEnded,
guestEmail,
initialGuestOptions,
moveAllDayRange,
+ PAST_EVENT_GUESTS_WARNING,
type SelectedEventEditorGuest,
} from './event-form-model';
@@ -88,6 +90,8 @@ function isEventComposerFormDirty(
export interface CreateCalendarEventFormControllerOptions {
initialValue: EventEditorInitialValues;
+ /** Editing a saved event, whose initial guests already hold an invitation. */
+ isEdit?: boolean;
calendarOptions: Accessor<EventEditorCalendarOption[]>;
guestOptions: Accessor<EventEditorGuestOption[]>;
recurrenceTimeZone?: string;
@@ -240,6 +244,31 @@ export function createCalendarEventFormController(
isEventComposerFormDirty(initialSnapshot(), snapshot())
);
+ const invitesNewGuests = () => {
+ // An unsaved event has invited nobody yet, no matter how its guest list
+ // was seeded: a calendar drag, or an event the assistant proposed.
+ if (options.isEdit !== true) return selectedGuests().length > 0;
+ const alreadyInvited = new Set(normalizedGuestEmails(initialGuestEmails()));
+ return normalizedGuestEmails(selectedGuests().map(guestEmail)).some(
+ (email) => !alreadyInvited.has(email)
+ );
+ };
+
+ const timeChanged = () =>
+ initialValue().allDay !== state().allDay ||
+ initialValue().start !== state().start ||
+ initialValue().end !== state().end;
+
+ // Inviting people to an event that already happened is nearly always a
+ // mistake, so the composer says so without blocking the save. Simply
+ // reopening a finished event stays quiet: only a new guest or a moved time
+ // sends anyone a fresh invitation.
+ const pastEventWarning = createMemo(() => {
+ if (selectedGuests().length === 0) return undefined;
+ if (!invitesNewGuests() && !timeChanged()) return undefined;
+ return eventHasEnded(state()) ? PAST_EVENT_GUESTS_WARNING : undefined;
+ });
+
const notifyChange = () => options.onChange?.(value());
const setReminderMinutes = (minutes: number[]) => {
@@ -351,6 +380,7 @@ export function createCalendarEventFormController(
changeRecurrenceChoice,
recurrenceLines: recurrence.recurrenceLines,
dateRangeError: recurrence.dateRangeError,
+ pastEventWarning,
eventTime: recurrence.eventTime,
canSave: recurrence.canSave,
snapshot,
diff --git a/apps/web/src/features/calendar/components/composer/event-form-model.test.ts b/apps/web/src/features/calendar/components/composer/event-form-model.test.ts
new file mode 100644
index 0000000000..58d561fc64
--- /dev/null
+++ b/apps/web/src/features/calendar/components/composer/event-form-model.test.ts
@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+import {
+ defaultEditorInitialValues,
+ type EventEditorInitialValues,
+ eventHasEnded,
+} from './event-form-model';
+
+const NOW = new Date('2026-08-25T12:00:00');
+
+function values(
+ overrides: Partial<EventEditorInitialValues>
+): EventEditorInitialValues {
+ return { ...defaultEditorInitialValues(NOW), ...overrides };
+}
+
+describe('eventHasEnded', () => {
+ it('treats a finished timed range as past', () => {
+ expect(
+ eventHasEnded(
+ values({ start: '2026-08-25T09:00', end: '2026-08-25T10:00' }),
+ NOW
+ )
+ ).toBe(true);
+ });
+
+ it('does not flag a range that is still running', () => {
+ expect(
+ eventHasEnded(
+ values({ start: '2026-08-25T11:30', end: '2026-08-25T12:30' }),
+ NOW
+ )
+ ).toBe(false);
+ });
+
+ it('does not flag a range that has not started', () => {
+ expect(
+ eventHasEnded(
+ values({ start: '2026-08-26T09:00', end: '2026-08-26T10:00' }),
+ NOW
+ )
+ ).toBe(false);
+ });
+
+ it('keeps an all-day event current until its last day is over', () => {
+ const today = values({
+ allDay: true,
+ start: '2026-08-25',
+ end: '2026-08-25',
+ });
+ expect(eventHasEnded(today, NOW)).toBe(false);
+ expect(eventHasEnded({ ...today, end: '2026-08-24' }, NOW)).toBe(true);
+ });
+
+ it('reports nothing while the range is unparseable', () => {
+ expect(eventHasEnded(values({ start: '', end: '' }), NOW)).toBe(false);
+ expect(
+ eventHasEnded(values({ allDay: true, start: '', end: '' }), NOW)
+ ).toBe(false);
+ });
+});
diff --git a/apps/web/src/features/calendar/components/composer/event-form-model.ts b/apps/web/src/features/calendar/components/composer/event-form-model.ts
index 60f1dd9f92..f4ee0f986a 100644
--- a/apps/web/src/features/calendar/components/composer/event-form-model.ts
+++ b/apps/web/src/features/calendar/components/composer/event-form-model.ts
@@ -12,6 +12,7 @@ import {
addDays,
addHours,
differenceInCalendarDays,
+ endOfDay,
format,
parseISO,
startOfHour,
@@ -245,6 +246,29 @@ export function buildEventTime(
};
}
+/** Copy shown when guests would be invited to an event that already ended. */
+export const PAST_EVENT_GUESTS_WARNING =
+ 'This event has already ended — guests will still be invited.';
+
+/** When the edited range ends, or `undefined` while the range does not parse. */
+export function eventEndsAt(state: EventEditorInitialValues): Date | undefined {
+ if (state.allDay) {
+ const end = parseLocalDate(state.end);
+ return end ? endOfDay(end) : undefined;
+ }
+ const end = new Date(state.end);
+ return Number.isNaN(end.getTime()) ? undefined : end;
+}
+
+/** Whether the edited range finished before `now`. In-progress events do not. */
+export function eventHasEnded(
+ state: EventEditorInitialValues,
+ now = new Date()
+) {
+ const endsAt = eventEndsAt(state);
+ return endsAt !== undefined && endsAt.getTime() < now.getTime();
+}
+
function parseGuestEmails(value: string) {
return [...new Set(value.split(/[\s,;]+/).filter((email) => email !== ''))];
}