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.

fix(calendar): refetch covered weeks whose cached events cannot be read (#8632)

gbirman2b81ebe229a0
diff --git a/apps/web/src/lib/queries/calendar/graphql/range.ts b/apps/web/src/lib/queries/calendar/graphql/range.ts
index 331be22ff2..2336ec868e 100644
--- a/apps/web/src/lib/queries/calendar/graphql/range.ts
+++ b/apps/web/src/lib/queries/calendar/graphql/range.ts
@@ -8,6 +8,7 @@ import {
readRecordsByKeys,
selectRecords,
} from '@graphql-cache/index';
+import { Telemetry } from '@macro-inc/observability';
import { CalendarSyncStatus } from '@service-storage/generated/schemas/calendarSyncStatus';
import {
CalendarOccurrenceItemFieldsFragmentDoc,
@@ -15,6 +16,7 @@ import {
type CalendarOccurrencesQuery,
type CalendarRangeInput,
} from '@service-storage/graphql/generated/graphql';
+import { ResultAsync } from 'neverthrow';
import type { CalendarOccurrenceQueryRange } from '../keys';
import type { CalendarOccurrencesData } from '../occurrences';
import { mapCalendarOccurrence, mapCalendarSyncStatus } from './map';
@@ -252,24 +254,118 @@ const occurrenceSelection = selectRecords(
CalendarOccurrenceItemFieldsFragmentDoc
);
+/**
+ * Reads the occurrences behind range keys. A key whose record lacks a field
+ * the selection asks for, such as one cached by a build with fewer fields,
+ * comes back unreadable rather than as an item.
+ */
async function readOccurrenceItems(
host: Pick<CacheHost, 'readRecordsByKeys'>,
keys: readonly string[]
) {
const items = [];
+ const unreadable: string[] = [];
for (
let index = 0;
index < keys.length;
index += MAX_RECORD_SELECTION_PAGE_SIZE
) {
+ const batch = keys.slice(index, index + MAX_RECORD_SELECTION_PAGE_SIZE);
const { records } = await readRecordsByKeys(
host,
occurrenceSelection,
- keys.slice(index, index + MAX_RECORD_SELECTION_PAGE_SIZE)
+ batch
);
- for (const { record } of records) items.push(mapCalendarOccurrence(record));
+ const read = new Set<string>();
+ for (const { recordKey, record } of records) {
+ read.add(recordKey);
+ items.push(mapCalendarOccurrence(record));
+ }
+ for (const key of batch) if (!read.has(key)) unreadable.push(key);
}
- return items;
+ return { items, unreadable };
+}
+
+// Unreadable keys each host already refetched, so a row the server no longer
+// returns costs one request per session rather than one per read.
+const refetchedUnreadable = new WeakMap<object, Set<string>>();
+
+function claimUnreadable(host: object, keys: readonly string[]): string[] {
+ let claimed = refetchedUnreadable.get(host);
+ if (!claimed) {
+ claimed = new Set();
+ refetchedUnreadable.set(host, claimed);
+ }
+ const fresh = keys.filter((key) => !claimed.has(key));
+ for (const key of fresh) claimed.add(key);
+ return fresh;
+}
+
+function releaseUnreadable(host: object, keys: readonly string[]): void {
+ const claimed = refetchedUnreadable.get(host);
+ for (const key of keys) claimed?.delete(key);
+}
+
+async function fetchViewport(
+ host: Pick<CacheHost, 'calendarCommit'>,
+ args: CalendarRangeCacheArgs,
+ fetchPage: FetchCalendarOccurrencePage,
+ signal?: AbortSignal
+): Promise<void> {
+ for (const window of calendarGapWindows([
+ { kind: 'timed', start: args.startMs, end: args.endMs },
+ { kind: 'allDay', start: args.startDay, end: args.endDay },
+ ])) {
+ await fetchCalendarWindow(host, window, fetchPage, signal);
+ }
+}
+
+/**
+ * Reads a covered viewport's occurrences. When the current build cannot read
+ * some of them, the viewport is refetched once, rewriting them with every
+ * field it selects, as any cache miss goes to the network. A failed refetch
+ * answers with what was readable, as the viewport does offline.
+ */
+async function readViewportItems(
+ host: Pick<
+ CacheHost,
+ 'calendarRange' | 'calendarCommit' | 'readRecordsByKeys'
+ >,
+ args: CalendarRangeCacheArgs,
+ occurrenceKeys: readonly string[],
+ fetchPage: FetchCalendarOccurrencePage,
+ signal?: AbortSignal
+): Promise<CalendarOccurrencesData['items'] | 'unsupported'> {
+ const read = await readOccurrenceItems(host, occurrenceKeys);
+ const unreadable = claimUnreadable(host, read.unreadable);
+ if (unreadable.length === 0) return read.items;
+ return Telemetry.span(
+ 'calendar.refetch_unreadable_occurrences',
+ async (span) => {
+ span.setAttr('calendar.cache.unreadable_count', unreadable.length);
+ const fetched = await ResultAsync.fromPromise(
+ fetchViewport(host, args, fetchPage, signal),
+ (error) => error
+ );
+ if (fetched.isErr()) {
+ // A later read retries what this one could not refetch.
+ releaseUnreadable(host, unreadable);
+ if (signal?.aborted) throw fetched.error;
+ span.setAttr('calendar.cache.refetch_outcome', 'failed');
+ span.error('Refetching unreadable calendar occurrences failed');
+ return read.items;
+ }
+ const result = await host.calendarRange(args);
+ if (result.kind === 'unsupported') return 'unsupported';
+ const reread = await readOccurrenceItems(host, result.occurrenceKeys);
+ span.setAttr('calendar.cache.refetch_outcome', 'refetched');
+ span.setAttr(
+ 'calendar.cache.still_unreadable_count',
+ reread.unreadable.length
+ );
+ return reread.items;
+ }
+ );
}
// The outstanding first read of each host that has not answered yet.
@@ -309,7 +405,10 @@ async function askCalendarRange(
return withinCacheHeadStart(answer, headStartMs);
}
-/** Answers a viewport from the cache, fetching only spans never fetched. */
+/**
+ * Answers a viewport from the cache, fetching only spans never fetched and,
+ * once per key, viewports whose cached occurrences cannot be read.
+ */
export async function readCalendarRange(
host: Pick<
CacheHost,
@@ -331,23 +430,21 @@ export async function readCalendarRange(
if (first === 'not-ready') return { kind: 'not-ready' };
let result = first;
if (result.kind === 'unsupported') return { kind: 'unsupported' };
+ const fetchPage = options.fetchPage ?? fetchCalendarOccurrencePage;
if (result.gaps.length > 0) {
for (const window of calendarGapWindows(result.gaps)) {
- await fetchCalendarWindow(
- host,
- window,
- options.fetchPage ?? fetchCalendarOccurrencePage,
- options.signal
- );
+ await fetchCalendarWindow(host, window, fetchPage, options.signal);
}
result = await host.calendarRange(args);
if (result.kind === 'unsupported') return { kind: 'unsupported' };
}
- return {
- kind: 'range',
- data: {
- items: await readOccurrenceItems(host, result.occurrenceKeys),
- syncStatus: latestSyncStatus,
- },
- };
+ const items = await readViewportItems(
+ host,
+ args,
+ result.occurrenceKeys,
+ fetchPage,
+ options.signal
+ );
+ if (items === 'unsupported') return { kind: 'unsupported' };
+ return { kind: 'range', data: { items, syncStatus: latestSyncStatus } };
}
diff --git a/apps/web/src/lib/queries/calendar/graphql/tests/range.test.ts b/apps/web/src/lib/queries/calendar/graphql/tests/range.test.ts
index 2c031d7736..4ad0b914ce 100644
--- a/apps/web/src/lib/queries/calendar/graphql/tests/range.test.ts
+++ b/apps/web/src/lib/queries/calendar/graphql/tests/range.test.ts
@@ -187,6 +187,84 @@ describe('readCalendarRange', () => {
expect(host.calendarCommit).not.toHaveBeenCalled();
});
+ it('refetches a covered viewport whose occurrences cannot be read', async () => {
+ const args = toCalendarRangeArgs(week);
+ const key = 'GraphqlCalendarOccurrence:event-1:a';
+ const host = fakeHost([
+ range({ occurrenceKeys: [key] }),
+ range({ occurrenceKeys: [key] }),
+ ]);
+ // A record cached by a build that selected fewer fields reads as a miss.
+ host.readRecordsByKeys.mockResolvedValueOnce({
+ revision: '2' as never,
+ records: [],
+ });
+ const fetchPage = vi.fn().mockResolvedValue(page());
+
+ const data = await readData(host, week, { fetchPage });
+
+ expect(fetchPage).toHaveBeenCalledTimes(1);
+ expect(fetchPage.mock.calls[0]?.[0]).toEqual({
+ start: week.start,
+ end: week.end,
+ startDate: week.startDate,
+ endDate: week.endDate,
+ first: 2000,
+ });
+ expect(host.calendarCommit).toHaveBeenCalledWith({
+ coverage: [
+ { kind: 'timed', start: args.startMs, end: args.endMs },
+ { kind: 'allDay', start: args.startDay, end: args.endDay },
+ ],
+ watermark: { kind: 'merge', links: [{ linkId: 'link-1', seq: '9' }] },
+ });
+ expect(host.calendarRange).toHaveBeenCalledTimes(2);
+ expect(data.items).toHaveLength(1);
+ });
+
+ it('refetches an unreadable occurrence once per host', async () => {
+ const key = 'GraphqlCalendarOccurrence:event-1:a';
+ const host = fakeHost([
+ range({ occurrenceKeys: [key] }),
+ range({ occurrenceKeys: [key] }),
+ range({ occurrenceKeys: [key] }),
+ ]);
+ host.readRecordsByKeys.mockResolvedValue({
+ revision: '2' as never,
+ records: [],
+ });
+ const fetchPage = vi.fn().mockResolvedValue(page());
+
+ expect((await readData(host, week, { fetchPage })).items).toEqual([]);
+ expect((await readData(host, week, { fetchPage })).items).toEqual([]);
+
+ expect(fetchPage).toHaveBeenCalledTimes(1);
+ expect(host.calendarRange).toHaveBeenCalledTimes(3);
+ });
+
+ it('answers with what it read when the refetch fails, and retries later', async () => {
+ const key = 'GraphqlCalendarOccurrence:event-1:a';
+ const host = fakeHost([
+ range({ occurrenceKeys: [key] }),
+ range({ occurrenceKeys: [key] }),
+ range({ occurrenceKeys: [key] }),
+ ]);
+ host.readRecordsByKeys
+ .mockResolvedValueOnce({ revision: '2' as never, records: [] })
+ .mockResolvedValueOnce({ revision: '2' as never, records: [] });
+ const fetchPage = vi
+ .fn()
+ .mockRejectedValueOnce(new Error('offline'))
+ .mockResolvedValueOnce(page());
+
+ expect((await readData(host, week, { fetchPage })).items).toEqual([]);
+ expect(host.calendarCommit).not.toHaveBeenCalled();
+
+ expect((await readData(host, week, { fetchPage })).items).toHaveLength(1);
+ expect(fetchPage).toHaveBeenCalledTimes(2);
+ expect(host.calendarCommit).toHaveBeenCalledTimes(1);
+ });
+
it('reports an unsupported host so the caller reads from REST', async () => {
const host = fakeHost([{ kind: 'unsupported' }]);
await expect(readCalendarRange(host, week)).resolves.toEqual({
diff --git a/docs/agent-guide/calendar.md b/docs/agent-guide/calendar.md
index cebe2b9b26..b75c856535 100644
--- a/docs/agent-guide/calendar.md
+++ b/docs/agent-guide/calendar.md
@@ -80,8 +80,12 @@ Calendar reads come from the local GraphQL cache when both `enable-graphql-soup`
and `enable-graphql-calendar` are on (PostHog in production, on by default in dev
for the calendar flag; set `VITE_ENABLE_GRAPHQL_CALENDAR=false` to test the REST
path). A range the cache has covered renders with no occurrence request, and a far
-jump fetches only the uncovered weeks. A `refresh_calendar` poke, reconnecting,
-coming online, or returning to the tab runs one `CalendarChanges` delta that
+jump fetches only the uncovered weeks. Cached records survive deploys, so an
+occurrence cached by an older build can lack a field the current one selects;
+a covered range with such occurrences refetches once instead of rendering
+without them (span `calendar.refetch_unreadable_occurrences`). A
+`refresh_calendar` poke, reconnecting, coming online, or returning to the tab
+runs one `CalendarChanges` delta that
applies edits made elsewhere. RSVPs, edits, deletions, and creates show at once
through the durable mutation queue: a rejected write rolls back with the usual
error, and a write made offline stays visible and replays on reconnect. Native