@wirecat/cli-core 0.454.0 → 0.456.0

package/dist/calendar/sync.js

@@ -0,0 +1,167 @@
+import { CliError } from "@wirecat/cli-base";
+import { isCliFailure } from "../errors/failures.js";
+const DAY = 86_400_000;
+export const parseCalendarCursor = (value) => {
+    if (value === null)
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed?.v !== 1 ||
+            (parsed.token !== null && typeof parsed.token !== "string") ||
+            typeof parsed.fullAt !== "number" ||
+            typeof parsed.window?.from !== "number" ||
+            typeof parsed.window.to !== "number")
+            return null;
+        return { v: 1, token: parsed.token, window: parsed.window, fullAt: parsed.fullAt };
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * One year back and three months ahead (NEED-1706), from the start of today in UTC. Whole days, so the window moves
+ * once a day: a source whose cursor holds the window lists everything again once a day, not on every run.
+ */
+export const calendarSyncWindow = (now) => {
+    const day = new Date(now);
+    const [year, month, date] = [day.getUTCFullYear(), day.getUTCMonth(), day.getUTCDate()];
+    return { from: Date.UTC(year - 1, month, date), to: Date.UTC(year, month + 3, date) };
+};
+const roundOf = async (source, store, calendar, cursor, window, now) => {
+    const round = { token: null, saved: 0, removed: 0, series: [] };
+    const seen = new Set();
+    let page;
+    for (;;) {
+        const result = await source.changes(calendar, { cursor, window, ...(page === undefined ? {} : { page }) });
+        if ("reset" in result)
+            return "reset";
+        if (result.entries.length) {
+            await store.saveEntries(calendar.id, result.entries, now);
+            round.saved += result.entries.length;
+            for (const entry of result.entries)
+                if (entry.kind === "series")
+                    round.series.push(entry);
+        }
+        if (result.removed.length)
+            round.removed += await store.removeEntries(calendar.id, result.removed, now);
+        if (result.nextPage === undefined) {
+            round.token = result.cursor ?? null;
+            return round;
+        }
+        if (seen.has(result.nextPage))
+            throw new CliError("invalid_response", `${source.provider} returned the same page twice`);
+        seen.add(result.nextPage);
+        page = result.nextPage;
+    }
+};
+const occurrencesOf = async (source, store, calendar, series, window, now, expand) => {
+    if (source.traits.expands === "in-changes")
+        return 0;
+    let saved = 0;
+    for (const one of series) {
+        if (one.status === "cancelled")
+            continue;
+        const slots = source.traits.expands === "local"
+            ? await expand(one, window)
+            : await source.occurrences(calendar, one.externalId, window);
+        if (!slots.length)
+            continue;
+        await store.saveEntries(calendar.id, slots, now);
+        saved += slots.length;
+    }
+    return saved;
+};
+const syncOne = async (source, store, calendar, { full: asked, window, now, expand }) => {
+    const stored = parseCalendarCursor(await store.cursor(calendar.id));
+    const windowMoved = stored !== null && (stored.window.from !== window.from || stored.window.to !== window.to);
+    // A full round once a day also asks every series for its slots again, which an incremental round does only for
+    // the series that changed (foundation §6.2 step 7).
+    let full = asked ||
+        source.traits.fullListOnly ||
+        stored === null ||
+        stored.token === null ||
+        (source.traits.cursorHoldsWindow && windowMoved) ||
+        now - stored.fullAt >= DAY;
+    let reset = false;
+    let round = await roundOf(source, store, calendar, full ? null : (stored?.token ?? null), window, now);
+    if (round === "reset") {
+        if (full)
+            throw new CliError("invalid_response", `${source.provider} refused a full list as a dead cursor`);
+        reset = true;
+        full = true;
+        await store.setCursor(calendar.id, null, now);
+        round = await roundOf(source, store, calendar, null, window, now);
+        if (round === "reset")
+            throw new CliError("invalid_response", `${source.provider} refused a full list as a dead cursor`);
+    }
+    const occurrences = await occurrencesOf(source, store, calendar, round.series, window, now, expand);
+    const unseen = full ? await store.markUnseen(calendar.id, now, window, now) : 0;
+    const cursor = { v: 1, token: round.token, window, fullAt: full ? now : (stored?.fullAt ?? now) };
+    await store.setCursor(calendar.id, JSON.stringify(cursor), now);
+    return {
+        calendarId: calendar.id,
+        externalId: calendar.externalId,
+        title: calendar.title,
+        round: full ? "full" : "changes",
+        reset,
+        saved: round.saved,
+        removed: round.removed,
+        occurrences,
+        unseen,
+    };
+};
+/**
+ * Brings one calendar account's synced calendars up to date (foundation §6.2): the calendar list first, then for
+ * each synced calendar its changes since the cursor, or a full list of the window, then the slots of the series that
+ * changed. Each calendar's cursor is saved last, only when all of it saved; a calendar that fails keeps its old one
+ * and the others go on.
+ */
+export const syncCalendars = async (source, store, options) => {
+    const now = options.now ?? Date.now();
+    const window = options.window ?? calendarSyncWindow(now);
+    if (source.traits.expands === "local" && !options.expand)
+        throw new CliError("configuration_error", `${source.provider} needs a local expander for its repeating events`);
+    if (source.traits.expands === "on-request" && !source.occurrences)
+        throw new CliError("configuration_error", `${source.provider} expands on request but has no occurrences()`);
+    const listed = await store.saveCalendars(options.accountId, await source.calendars(), now);
+    const report = {
+        provider: source.provider,
+        accountId: options.accountId,
+        window,
+        calendars: listed.length,
+        synced: [],
+        notSynced: [],
+        complete: true,
+    };
+    for (const calendar of listed) {
+        if (!calendar.synced) {
+            report.notSynced.push({ calendarId: calendar.id, externalId: calendar.externalId, title: calendar.title });
+            continue;
+        }
+        try {
+            report.synced.push(await syncOne(source, store, calendar, {
+                full: options.full === true,
+                window,
+                now,
+                ...(options.expand ? { expand: options.expand } : {}),
+            }));
+        }
+        catch (error) {
+            report.complete = false;
+            report.synced.push({
+                calendarId: calendar.id,
+                externalId: calendar.externalId,
+                title: calendar.title,
+                round: options.full ? "full" : "changes",
+                reset: false,
+                saved: 0,
+                removed: 0,
+                occurrences: 0,
+                unseen: 0,
+                // An adapter's own failure says what went wrong; anything else may carry a request URL with a token in it.
+                error: isCliFailure(error) ? error.message : "the calendar could not be synced",
+            });
+        }
+    }
+    return report;
+};

package/dist/calendar/testing/index.d.ts

@@ -0,0 +1,5 @@
+export { CONTRACT_NOW, type EventStoreFixture, eventStoreContract } from "../../meetings/testing/index.js";
+export { memoryEventStore } from "./memory.js";
+export { type FakeCalendarSource, type FakeCalendarSourceOptions, fakeCalendarSource } from "./source.js";
+export { type CalendarSourceFixture, calendarSourceContract } from "./source-contract.js";
+export { CALENDAR_TRAIT_COMBINATIONS, type CalendarSyncFixture, calendarSyncContract } from "./sync-contract.js";

package/dist/calendar/testing/index.js

@@ -0,0 +1,5 @@
+export { CONTRACT_NOW, eventStoreContract } from "../../meetings/testing/index.js";
+export { memoryEventStore } from "./memory.js";
+export { fakeCalendarSource } from "./source.js";
+export { calendarSourceContract } from "./source-contract.js";
+export { CALENDAR_TRAIT_COMBINATIONS, calendarSyncContract } from "./sync-contract.js";

package/dist/calendar/testing/memory.d.ts

@@ -0,0 +1,6 @@
+import type { EventStore } from "../../meetings/index.js";
+/**
+ * An `EventStore` in memory, for CLI and engine tests: it passes `eventStoreContract`. Rule 4 (an entry adopting a
+ * Zoom meeting's event by its room) needs meetings, which this store does not hold; a person is one contact.
+ */
+export declare const memoryEventStore: () => EventStore;

package/dist/calendar/testing/memory.js

@@ -0,0 +1,478 @@
+import { CliError } from "@wirecat/cli-base";
+import { calendarText, joinKeyOf, joinUrlWithoutQuery } from "../../meetings/index.js";
+const TRACKED = ["title", "startsAt", "endsAt", "location", "status", "recurrence", "recurrenceEndsAt"];
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+ * An `EventStore` in memory, for CLI and engine tests: it passes `eventStoreContract`. Rule 4 (an entry adopting a
+ * Zoom meeting's event by its room) needs meetings, which this store does not hold; a person is one contact.
+ */
+export const memoryEventStore = () => {
+    const calendars = [];
+    const entries = [];
+    const events = new Map();
+    const series = new Map();
+    const revisions = [];
+    let participants = [];
+    let attachments = [];
+    const reviews = [];
+    const cursors = new Map();
+    const unlinked = new Set();
+    const contacts = new Map();
+    let nextId = 1;
+    const calendarOf = (id) => {
+        const calendar = calendars.find((one) => one.id === id);
+        if (!calendar)
+            throw new CliError("not_found", `no calendar ${id} in the local store`);
+        return calendar;
+    };
+    const contactOf = (email) => {
+        const address = email.trim().toLowerCase();
+        if (!contacts.has(address))
+            contacts.set(address, nextId++);
+        return contacts.get(address);
+    };
+    const stored = ({ updatedAt: _, ...entry }) => ({ ...entry });
+    const entityOf = (entry) => (entry.kind === "series" ? entry.eventSeriesId : entry.eventId);
+    const setEntity = (entry, to, now) => {
+        if (entry.kind === "series")
+            entry.eventSeriesId = to;
+        else
+            entry.eventId = to;
+        entry.updatedAt = now;
+    };
+    const revise = (entry, now) => revisions.push({
+        entryId: entry.id,
+        title: entry.title,
+        startsAt: entry.startsAt,
+        endsAt: entry.endsAt,
+        location: entry.location,
+        status: entry.status,
+        recurrence: entry.recurrence,
+        recurrenceEndsAt: entry.recurrenceEndsAt,
+        externalUpdatedAt: entry.externalUpdatedAt,
+        createdAt: now,
+    });
+    const candidatesFor = (entry) => {
+        if (!entry.icalUid)
+            return [];
+        const ids = entries
+            .filter((one) => one.icalUid === entry.icalUid &&
+            one.calendarId !== entry.calendarId &&
+            one.kind === entry.kind &&
+            one.deletedAt === null &&
+            entityOf(one) !== null &&
+            one.originalStartsAt === entry.originalStartsAt)
+            .map((one) => entityOf(one));
+        return [...new Set(ids)].sort((a, b) => a - b);
+    };
+    const link = (entry, now) => {
+        if (entityOf(entry) !== null || unlinked.has(entry.id))
+            return;
+        const ids = candidatesFor(entry);
+        if (ids.length > 1) {
+            const entity = entry.kind === "series" ? "event_series" : "event";
+            const open = reviews.find((one) => one.linkableType === "calendar_entry" && one.linkableId === entry.id && one.entityType === entity);
+            if (!open)
+                reviews.push({
+                    id: nextId++,
+                    linkableType: "calendar_entry",
+                    linkableId: entry.id,
+                    entityType: entity,
+                    candidates: ids,
+                    reason: "ical-uid",
+                    status: "open",
+                    chosenId: null,
+                    decidedBy: null,
+                    decidedAt: null,
+                    createdAt: now,
+                });
+            else if (open.status === "open")
+                open.candidates = ids;
+            return;
+        }
+        if (ids.length === 1)
+            return setEntity(entry, ids[0], now);
+        if (entry.status === "cancelled")
+            return;
+        setEntity(entry, newEntity(entry, now), now);
+    };
+    const newEntity = (entry, now) => {
+        const id = nextId++;
+        if (entry.kind === "series")
+            series.set(id, { id, title: entry.title, recurrence: entry.recurrence });
+        else
+            events.set(id, {
+                id,
+                eventSeriesId: null,
+                title: entry.title,
+                description: null,
+                location: null,
+                startsAt: entry.startsAt,
+                endsAt: entry.endsAt,
+                timezone: entry.timezone,
+                origin: "calendar",
+                deletedAt: null,
+                status: null,
+                allDay: false,
+                sourceDeletedAt: null,
+                createdAt: now,
+                updatedAt: now,
+            });
+        return id;
+    };
+    const hasText = (entry) => `${entry.title ?? ""}${entry.description ?? ""}${entry.location ?? ""}`.trim() !== "";
+    const own = (entry) => participants.some((p) => p.entryId === entry.id && p.self && p.organizer);
+    const refreshEvent = (eventId, now) => {
+        const event = events.get(eventId);
+        if (!event)
+            return;
+        const live = entries
+            .filter((one) => one.eventId === eventId && one.deletedAt === null)
+            .sort((a, b) => Number(hasText(b)) - Number(hasText(a)) ||
+            Number(own(b)) - Number(own(a)) ||
+            (b.externalUpdatedAt ?? b.updatedAt) - (a.externalUpdatedAt ?? a.updatedAt) ||
+            b.id - a.id);
+        const preferred = live[0];
+        if (!preferred) {
+            if (!entries.some((one) => one.eventId === eventId))
+                return;
+            if (event.startsAt !== null && event.startsAt < now)
+                event.sourceDeletedAt ??= now;
+            else
+                event.status = "cancelled";
+            event.updatedAt = now;
+            return;
+        }
+        const cancelled = live.every((one) => one.status === "cancelled");
+        const startsAt = preferred.startsAt ?? event.startsAt;
+        const past = startsAt !== null && startsAt < now;
+        const seriesEntry = preferred.seriesEntryId === null ? null : entries.find((one) => one.id === preferred.seriesEntryId);
+        if (!(cancelled && past))
+            Object.assign(event, {
+                title: preferred.title,
+                description: preferred.description,
+                location: preferred.location,
+                startsAt: preferred.startsAt,
+                endsAt: preferred.endsAt,
+            });
+        event.timezone = preferred.timezone;
+        event.allDay = preferred.allDay;
+        event.status = cancelled ? (past ? event.status : "cancelled") : preferred.status;
+        event.sourceDeletedAt = cancelled && past ? (event.sourceDeletedAt ?? now) : null;
+        event.eventSeriesId = seriesEntry?.eventSeriesId ?? event.eventSeriesId;
+        event.updatedAt = now;
+    };
+    const refreshSeries = (seriesId) => {
+        const preferred = entries
+            .filter((one) => one.eventSeriesId === seriesId && one.deletedAt === null)
+            .sort((a, b) => (b.externalUpdatedAt ?? b.updatedAt) - (a.externalUpdatedAt ?? a.updatedAt) || b.id - a.id)[0];
+        const held = series.get(seriesId);
+        if (preferred && held)
+            Object.assign(held, { title: preferred.title, recurrence: preferred.recurrence });
+    };
+    const refreshAround = (ids, now) => {
+        const touched = entries.filter((one) => ids.includes(one.id) || (one.seriesEntryId !== null && ids.includes(one.seriesEntryId)));
+        for (const one of touched) {
+            if (one.eventSeriesId !== null)
+                refreshSeries(one.eventSeriesId);
+            if (one.eventId !== null)
+                refreshEvent(one.eventId, now);
+        }
+    };
+    const cancel = (entry, now) => {
+        revise(entry, now);
+        entry.status = "cancelled";
+        entry.updatedAt = now;
+    };
+    const cancelOccurrences = (seriesEntryId, now) => {
+        for (const one of entries)
+            if (one.seriesEntryId === seriesEntryId && one.status !== "cancelled" && one.deletedAt === null)
+                cancel(one, now);
+    };
+    const existingFor = (calendarId, input, seriesEntryId) => {
+        const found = entries.find((one) => one.calendarId === calendarId && one.externalId === input.externalId);
+        if (found || input.kind !== "occurrence" || input.originalStartsAt == null)
+            return found;
+        return entries.find((one) => seriesEntryId !== null
+            ? one.seriesEntryId === seriesEntryId && one.originalStartsAt === input.originalStartsAt
+            : one.calendarId === calendarId &&
+                one.seriesEntryId === null &&
+                one.originalStartsAt === input.originalStartsAt &&
+                one.seriesExternalId === (input.seriesExternalId ?? null));
+    };
+    const saveEntry = (calendarId, input, now) => {
+        if (input.startsAt != null && input.endsAt != null && input.endsAt < input.startsAt)
+            throw new CliError("validation_error", `calendar entry ${input.externalId} ends before it starts`);
+        const seriesEntry = input.kind === "occurrence" && input.seriesExternalId
+            ? entries.find((one) => one.calendarId === calendarId && one.externalId === input.seriesExternalId && one.kind === "series")
+            : undefined;
+        const seriesEntryId = seriesEntry?.id ?? null;
+        const joinUrl = joinUrlWithoutQuery(input.joinUrl);
+        const values = {
+            kind: input.kind,
+            seriesEntryId,
+            seriesExternalId: input.kind === "occurrence" ? (input.seriesExternalId ?? null) : null,
+            externalId: input.externalId,
+            icalUid: input.icalUid ?? null,
+            originalStartsAt: input.originalStartsAt ?? null,
+            exception: input.exception === true,
+            status: input.status,
+            title: calendarText(input.title, { dropSecretLines: false }),
+            description: calendarText(input.description),
+            location: calendarText(input.location),
+            startsAt: input.startsAt ?? null,
+            endsAt: input.endsAt ?? null,
+            allDay: input.allDay === true,
+            startDate: input.startDate ?? null,
+            endDate: input.endDate ?? null,
+            timezone: input.timezone ?? null,
+            recurrence: input.recurrence ?? null,
+            recurrenceEndsAt: input.recurrenceEndsAt ?? null,
+            eventType: input.eventType ?? null,
+            ownResponse: input.ownResponse ?? null,
+            organizerIdentityId: input.organizer ? contactOf(input.organizer.email) : null,
+            joinUrl,
+            joinKey: joinUrl ? (joinKeyOf(joinUrl) ?? "") : null,
+            url: input.url ?? null,
+            externalUpdatedAt: input.externalUpdatedAt ?? null,
+            seenAt: now,
+            deletedAt: null,
+            updatedAt: now,
+        };
+        let entry = existingFor(calendarId, input, seriesEntryId);
+        if (entry) {
+            const found = entry;
+            if (TRACKED.some((key) => !same(found[key], values[key])))
+                revise(found, now);
+            Object.assign(found, values);
+        }
+        else {
+            entry = { id: nextId++, calendarId, eventId: null, eventSeriesId: null, ...values };
+            entries.push(entry);
+        }
+        const id = entry.id;
+        if (input.participants) {
+            const kept = new Map();
+            for (const one of input.participants) {
+                const email = one.email.trim().toLowerCase();
+                if (!email || kept.has(email))
+                    continue;
+                kept.set(email, {
+                    entryId: id,
+                    identityId: one.resource ? null : contactOf(email),
+                    email,
+                    name: one.name ?? null,
+                    response: one.response ?? null,
+                    optional: one.optional === true,
+                    organizer: one.organizer === true,
+                    self: one.self === true,
+                    resource: one.resource === true,
+                });
+            }
+            participants = [
+                ...participants.filter((p) => p.entryId !== id),
+                ...[...kept.values()].sort((a, b) => a.email.localeCompare(b.email)),
+            ];
+        }
+        if (input.attachments) {
+            const files = [...new Set(input.attachments.map(({ fileId }) => fileId.trim()).filter(Boolean))];
+            attachments = [
+                ...attachments.filter((a) => a.entryId !== id),
+                ...files.map((fileId) => ({
+                    entryId: id,
+                    fileId,
+                    title: input.attachments?.find((a) => a.fileId.trim() === fileId)?.title ?? null,
+                    documentId: null,
+                })),
+            ];
+        }
+        if (input.kind === "series")
+            for (const one of entries)
+                if (one.calendarId === calendarId &&
+                    one.kind === "occurrence" &&
+                    one.seriesEntryId === null &&
+                    one.seriesExternalId === input.externalId)
+                    one.seriesEntryId = id;
+        return entry;
+    };
+    const entryOf = (id) => {
+        const entry = entries.find((one) => one.id === id);
+        if (!entry)
+            throw new CliError("not_found", `no calendar entry ${id} in the local store`);
+        return entry;
+    };
+    return {
+        async saveCalendars(accountId, list, now) {
+            return list.map((one) => {
+                let calendar = calendars.find((held) => held.accountId === accountId && held.externalId === one.externalId);
+                if (!calendar) {
+                    calendar = {
+                        id: nextId++,
+                        accountId,
+                        externalId: one.externalId,
+                        title: null,
+                        timezone: null,
+                        accessRole: null,
+                        primary: false,
+                        synced: one.syncByDefault,
+                        seenAt: null,
+                        deletedAt: null,
+                    };
+                    calendars.push(calendar);
+                }
+                Object.assign(calendar, {
+                    title: one.title,
+                    timezone: one.timezone,
+                    accessRole: one.accessRole,
+                    primary: one.primary,
+                    seenAt: now,
+                    deletedAt: null,
+                });
+                return { ...calendar };
+            });
+        },
+        async calendars(accountId) {
+            return calendars
+                .filter((one) => one.accountId === accountId)
+                .sort((a, b) => Number(b.primary) - Number(a.primary) || (a.title ?? "").localeCompare(b.title ?? "") || a.id - b.id)
+                .map((one) => ({ ...one }));
+        },
+        async setCalendarSynced(calendarId, synced) {
+            calendarOf(calendarId).synced = synced;
+        },
+        async saveEntries(calendarId, list, now) {
+            calendarOf(calendarId);
+            for (const input of list)
+                if (input.startsAt != null && input.endsAt != null && input.endsAt < input.startsAt)
+                    throw new CliError("validation_error", `calendar entry ${input.externalId} ends before it starts`);
+            const ordered = [...list].sort((a, b) => Number(b.kind === "series") - Number(a.kind === "series"));
+            const saved = new Map();
+            for (const input of ordered)
+                saved.set(input, saveEntry(calendarId, input, now));
+            for (const entry of saved.values())
+                if (entry.kind === "series" && entry.status === "cancelled")
+                    cancelOccurrences(entry.id, now);
+            for (const entry of saved.values())
+                link(entry, now);
+            refreshAround([...saved.values()].map(({ id }) => id), now);
+            return list.map((input) => stored(saved.get(input)));
+        },
+        async removeEntries(calendarId, externalIds, now) {
+            calendarOf(calendarId);
+            const removed = entries.filter((one) => one.calendarId === calendarId &&
+                externalIds.includes(one.externalId) &&
+                one.status !== "cancelled" &&
+                one.deletedAt === null);
+            for (const one of removed) {
+                cancel(one, now);
+                one.seenAt = now;
+                if (one.kind === "series")
+                    cancelOccurrences(one.id, now);
+            }
+            refreshAround(removed.map(({ id }) => id), now);
+            return removed.length;
+        },
+        async markUnseen(calendarId, seenBefore, window, now) {
+            const marked = entries.filter((one) => one.calendarId === calendarId &&
+                one.deletedAt === null &&
+                (one.seenAt === null || one.seenAt < seenBefore) &&
+                (one.kind !== "occurrence" ||
+                    one.exception ||
+                    (one.originalStartsAt !== null && one.originalStartsAt >= window.from && one.originalStartsAt < window.to)));
+            for (const one of marked)
+                Object.assign(one, { deletedAt: now, updatedAt: now });
+            for (const eventId of new Set(marked.map(({ eventId }) => eventId)))
+                if (eventId !== null)
+                    refreshEvent(eventId, now);
+            return marked.length;
+        },
+        async cursor(calendarId) {
+            return cursors.get(calendarId) ?? null;
+        },
+        async setCursor(calendarId, value) {
+            calendarOf(calendarId);
+            if (value === null)
+                cursors.delete(calendarId);
+            else
+                cursors.set(calendarId, value);
+        },
+        async events(filter = {}) {
+            const limit = filter.limit ?? 100;
+            const offset = filter.offset ?? 0;
+            if (!Number.isInteger(limit) || limit < 1 || limit > 1000 || !Number.isInteger(offset) || offset < 0)
+                throw new CliError("validation_error", "limit takes 1–1000 and offset 0 or more");
+            const has = (event, check) => entries.some((one) => one.eventId === event.id && check(one));
+            return [...events.values()]
+                .filter((event) => event.deletedAt === null &&
+                (filter.from === undefined || (event.endsAt ?? (event.startsAt ?? 0) + 1) > filter.from) &&
+                (filter.to === undefined || (event.startsAt !== null && event.startsAt < filter.to)) &&
+                (filter.calendarId === undefined || has(event, (one) => one.calendarId === filter.calendarId)) &&
+                (filter.accountId === undefined ||
+                    has(event, (one) => calendarOf(one.calendarId).accountId === filter.accountId)) &&
+                (filter.personId === undefined ||
+                    has(event, (one) => participants.some((p) => p.entryId === one.id && p.identityId === filter.personId))))
+                .sort((a, b) => ((a.startsAt ?? -1) - (b.startsAt ?? -1) || a.id - b.id) * (filter.newest ? -1 : 1))
+                .slice(offset, offset + limit)
+                .map((event) => ({ ...event }));
+        },
+        async event(id) {
+            const event = events.get(id);
+            if (!event)
+                return null;
+            const held = entries.filter((one) => one.eventId === id).sort((a, b) => a.id - b.id);
+            const ids = new Set(held.map(({ id }) => id));
+            return {
+                event: { ...event },
+                entries: held.map(stored),
+                participants: participants
+                    .filter((p) => ids.has(p.entryId))
+                    .sort((a, b) => a.entryId - b.entryId || a.email.localeCompare(b.email))
+                    .map((p) => ({ ...p })),
+                revisions: revisions.filter((r) => ids.has(r.entryId)).map((r) => ({ ...r })),
+                attachments: attachments.filter((a) => ids.has(a.entryId)).map((a) => ({ ...a })),
+            };
+        },
+        async linkEntry(entryId, eventId, now) {
+            const entry = entryOf(entryId);
+            if (!(entry.kind === "series" ? series.has(eventId) : events.has(eventId)))
+                throw new CliError("not_found", `no ${entry.kind === "series" ? "event series" : "event"} ${eventId}`);
+            unlinked.delete(entryId);
+            setEntity(entry, eventId, now);
+            if (entry.kind !== "series")
+                refreshEvent(eventId, now);
+        },
+        async unlinkEntry(entryId, now) {
+            const entry = entryOf(entryId);
+            unlinked.add(entryId);
+            setEntity(entry, null, now);
+        },
+        async reviews(filter = {}) {
+            return reviews
+                .filter((one) => !filter.status || one.status === filter.status)
+                .map((one) => ({ ...one, candidates: [...one.candidates] }));
+        },
+        async resolveReview(id, decision, now) {
+            const review = reviews.find((one) => one.id === id);
+            if (!review)
+                throw new CliError("not_found", `no review ${id} in the local store`);
+            if (review.status !== "open")
+                throw new CliError("validation_error", `review ${id} is already ${review.status}`);
+            if ("choose" in decision && !review.candidates.includes(decision.choose))
+                throw new CliError("validation_error", `${decision.choose} is not one of review ${id}'s candidates`);
+            const chosen = "choose" in decision ? decision.choose : null;
+            if (review.linkableType === "calendar_entry") {
+                const entry = entryOf(review.linkableId);
+                setEntity(entry, chosen ?? newEntity(entry, now), now);
+                if (chosen !== null && review.entityType === "event")
+                    refreshEvent(chosen, now);
+            }
+            Object.assign(review, {
+                status: chosen === null ? "apart" : "linked",
+                chosenId: chosen,
+                decidedBy: "owner",
+                decidedAt: now,
+            });
+            return { ...review, candidates: [...review.candidates] };
+        },
+    };
+};