Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
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.tsindex 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.tsindex 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.mdindex 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 devfor the calendar flag; set `VITE_ENABLE_GRAPHQL_CALENDAR=false` to test the RESTpath). 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 thatapplies edits made elsewhere. RSVPs, edits, deletions, and creates show at oncethrough the durable mutation queue: a rejected write rolls back with the usualerror, and a write made offline stays visible and replays on reconnect. Native