@wirecat/cli-core 0.418.0 → 0.420.0

package/dist/store/sqlite/calendar.js

@@ -0,0 +1,593 @@
+import { CliError } from "@wirecat/cli-base";
+import { calendarText, entryMetadata, joinKeyOf, joinUrlWithoutQuery, } from "../../meetings/index.js";
+import { bool, eventOf, fromJson, int, str, toJson } from "./events.js";
+import { logFileLink } from "./files.js";
+import { identityOf } from "./identities.js";
+import { reviewLink } from "./link-reviews.js";
+import { read, write } from "./transaction.js";
+const calendarOf = (row) => ({
+    id: Number(row.id),
+    accountId: Number(row.account_id),
+    externalId: String(row.external_id),
+    title: str(row.title),
+    timezone: str(row.timezone),
+    accessRole: str(row.access_role),
+    primary: Number(row.primary_calendar) === 1,
+    synced: Number(row.synced) === 1,
+    seenAt: int(row.seen_at),
+    deletedAt: int(row.deleted_at),
+});
+const entryOf = (row) => ({
+    id: Number(row.id),
+    calendarId: Number(row.calendar_id),
+    kind: row.kind,
+    seriesEntryId: int(row.series_entry_id),
+    eventId: int(row.event_id),
+    eventSeriesId: int(row.event_series_id),
+    externalId: String(row.external_id),
+    icalUid: str(row.ical_uid),
+    originalStartsAt: int(row.original_starts_at),
+    exception: Number(row.exception) === 1,
+    status: row.status,
+    title: str(row.title),
+    description: str(row.description),
+    location: str(row.location),
+    startsAt: int(row.starts_at),
+    endsAt: int(row.ends_at),
+    allDay: Number(row.all_day) === 1,
+    startDate: str(row.start_date),
+    endDate: str(row.end_date),
+    timezone: str(row.timezone),
+    recurrence: fromJson(row.recurrence),
+    recurrenceEndsAt: int(row.recurrence_ends_at),
+    eventType: str(row.event_type),
+    ownResponse: str(row.own_response),
+    organizerIdentityId: int(row.organizer_identity_id),
+    joinUrl: str(row.join_url),
+    joinKey: str(row.join_key),
+    url: str(row.url),
+    externalUpdatedAt: int(row.external_updated_at),
+    seenAt: int(row.seen_at),
+    deletedAt: int(row.deleted_at),
+});
+const participantOf = (row) => ({
+    entryId: Number(row.entry_id),
+    identityId: int(row.identity_id),
+    email: String(row.email),
+    name: str(row.name),
+    response: str(row.response),
+    optional: bool(row.optional) === true,
+    organizer: bool(row.organizer) === true,
+    self: bool(row.self) === true,
+    resource: bool(row.resource) === true,
+});
+const revisionOf = (row) => ({
+    entryId: Number(row.entry_id),
+    title: str(row.title),
+    startsAt: int(row.starts_at),
+    endsAt: int(row.ends_at),
+    location: str(row.location),
+    status: str(row.status),
+    recurrence: fromJson(row.recurrence),
+    recurrenceEndsAt: int(row.recurrence_ends_at),
+    externalUpdatedAt: int(row.external_updated_at),
+    createdAt: Number(row.created_at),
+});
+const reviewOf = (row) => ({
+    id: Number(row.id),
+    linkableType: String(row.linkable_type),
+    linkableId: Number(row.linkable_id),
+    entityType: String(row.entity_type),
+    candidates: fromJson(row.candidates),
+    reason: String(row.reason),
+    status: row.status,
+    chosenId: int(row.chosen_id),
+    decidedBy: str(row.decided_by),
+    decidedAt: int(row.decided_at),
+    createdAt: Number(row.created_at),
+});
+const TRACKED = ["title", "starts_at", "ends_at", "location", "status", "recurrence", "recurrence_ends_at"];
+const flag = (value) => (value ? 1 : 0);
+const addressOf = (email) => email.trim().toLowerCase();
+/** The `email` contact of an address: the same one mail uses, made when missing; it gets a name only when new. */
+const contactOf = (context, email, name) => {
+    const address = addressOf(email);
+    if (!/^[^\s@]+@[^\s@]+$/u.test(address))
+        return null;
+    const found = context.database
+        .prepare("SELECT id FROM identities WHERE provider = 'email' AND external_id = ?")
+        .get(address);
+    return found ? Number(found.id) : identityOf(context, "email", address, name ?? null);
+};
+const logLink = (database, { type, id, entity, from, to, method, author, now }) => {
+    database
+        .prepare("INSERT INTO entity_link_events (linkable_type, linkable_id, entity_type, from_entity_id, to_entity_id, method, " +
+        "confidence, author, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)")
+        .run(type, id, entity, from, to, method, author === "owner" ? 1 : null, author, now);
+};
+/** The owner's last word on a source record: once they unlinked it, no rule links it again. */
+const ownerUnlinked = (database, type, id) => {
+    const last = database
+        .prepare("SELECT to_entity_id FROM entity_link_events WHERE linkable_type = ? AND linkable_id = ? AND author = 'owner' " +
+        "ORDER BY id DESC LIMIT 1")
+        .get(type, id);
+    return last !== undefined && last.to_entity_id == null;
+};
+const distinctIds = (rows, column = "id") => [...new Set(rows.map((row) => Number(row[column])))];
+const overlap = "starts_at < ? AND coalesce(ends_at, starts_at + 1) > ?";
+/** The entry's time as an interval that is never empty, so a point in time still overlaps what it falls in. */
+const spanOf = (entry) => {
+    const start = entry.startsAt ?? 0;
+    return { start, end: Math.max(entry.endsAt ?? start, start + 1) };
+};
+export const eventStoreOver = (context) => {
+    const { database } = context;
+    const entryRow = (id) => database.prepare("SELECT * FROM calendar_entries WHERE id = ?").get(id);
+    const calendarRow = (id) => {
+        const row = database.prepare("SELECT * FROM calendars WHERE id = ?").get(id);
+        if (!row)
+            throw new CliError("not_found", `no calendar ${id} in the local store`);
+        return row;
+    };
+    /** Rule 3, then rule 4: the entities this entry may be a copy of. */
+    const candidatesFor = (entry) => {
+        const entity = entry.kind === "series" ? "event_series_id" : "event_id";
+        if (entry.icalUid) {
+            const rows = database
+                .prepare(`SELECT DISTINCT ${entity} AS id FROM calendar_entries WHERE ical_uid = ? AND calendar_id <> ? AND kind = ?
+             AND deleted_at IS NULL AND ${entity} IS NOT NULL AND original_starts_at IS ?`)
+                .all(entry.icalUid, entry.calendarId, entry.kind, entry.originalStartsAt);
+            if (rows.length)
+                return { ids: distinctIds(rows), method: "ical-uid" };
+        }
+        if (entry.joinKey) {
+            if (entry.kind === "series") {
+                const rows = database
+                    .prepare("SELECT DISTINCT s.id, ms.join_url FROM event_series s JOIN meeting_series ms ON ms.event_series_id = s.id " +
+                    "WHERE s.origin = 'auto' AND ms.deleted_at IS NULL AND ms.join_url IS NOT NULL")
+                    .all()
+                    .filter((row) => joinKeyOf(str(row.join_url)) === entry.joinKey);
+                return { ids: distinctIds(rows), method: "join-key" };
+            }
+            const { start, end } = spanOf(entry);
+            const rows = database
+                .prepare(`SELECT DISTINCT e.id FROM events e JOIN meetings m ON m.event_id = e.id
+            WHERE e.origin = 'auto' AND e.deleted_at IS NULL AND m.deleted_at IS NULL AND m.join_key = ?
+              AND e.${overlap}`)
+                .all(entry.joinKey, end, start);
+            return { ids: distinctIds(rows), method: "join-key" };
+        }
+        return { ids: [], method: "new" };
+    };
+    const setEntity = (entry, to, method, author, now) => {
+        const column = entry.kind === "series" ? "event_series_id" : "event_id";
+        const from = entry.kind === "series" ? entry.eventSeriesId : entry.eventId;
+        database.prepare(`UPDATE calendar_entries SET ${column} = ?, updated_at = ? WHERE id = ?`).run(to, now, entry.id);
+        logLink(database, {
+            type: "calendar_entry",
+            id: entry.id,
+            entity: entry.kind === "series" ? "event_series" : "event",
+            from,
+            to,
+            method,
+            author,
+            now,
+        });
+    };
+    const newEntity = (entry, now) => entry.kind === "series"
+        ? Number(database
+            .prepare("INSERT INTO event_series (title, recurrence, origin, created_at, updated_at) VALUES (?, ?, 'calendar', ?, ?) RETURNING id")
+            .get(entry.title, toJson(entry.recurrence), now, now)?.id)
+        : Number(database
+            .prepare("INSERT INTO events (title, starts_at, ends_at, timezone, origin, created_at, updated_at) VALUES (?, ?, ?, ?, 'calendar', ?, ?) RETURNING id")
+            .get(entry.title, entry.startsAt, entry.endsAt, entry.timezone, now, now)?.id);
+    /** Rules 3–5 for an entry with no entity yet. */
+    const link = (entry, now) => {
+        const linked = entry.kind === "series" ? entry.eventSeriesId : entry.eventId;
+        if (linked !== null || ownerUnlinked(database, "calendar_entry", entry.id))
+            return;
+        const entity = entry.kind === "series" ? "event_series" : "event";
+        const { ids, method } = candidatesFor(entry);
+        if (ids.length > 1)
+            return reviewLink(database, { type: "calendar_entry", id: entry.id }, entity, ids, method, now);
+        if (ids.length === 1) {
+            const [id] = ids;
+            setEntity(entry, id, method, "rules", now);
+            if (method === "join-key")
+                database
+                    .prepare(`UPDATE ${entity === "event" ? "events" : "event_series"} SET origin = 'calendar', updated_at = ? WHERE id = ?`)
+                    .run(now, id);
+            return;
+        }
+        // A slot cancelled before it was ever stored is no event.
+        if (entry.status === "cancelled")
+            return;
+        setEntity(entry, newEntity(entry, now), "new", "rules", now);
+    };
+    /** The event's fields from its preferred entry: the owner's copy when the owner organizes, else the latest. */
+    const refreshEvent = (eventId, now) => {
+        const entries = database
+            .prepare(`SELECT ce.*, EXISTS (SELECT 1 FROM calendar_entry_participants p WHERE p.entry_id = ce.id AND p.self = 1
+           AND p.organizer = 1) AS own FROM calendar_entries ce WHERE ce.event_id = ? AND ce.deleted_at IS NULL
+         ORDER BY own DESC, coalesce(ce.external_updated_at, ce.updated_at) DESC, ce.id DESC`)
+            .all(eventId);
+        const preferred = entries[0];
+        if (!preferred)
+            return;
+        const event = database.prepare("SELECT * FROM events WHERE id = ?").get(eventId);
+        const cancelled = entries.every((row) => row.status === "cancelled");
+        const series = preferred.series_entry_id == null ? null : entryRow(Number(preferred.series_entry_id));
+        const startsAt = int(preferred.starts_at) ?? int(event.starts_at);
+        // History: what was on the calendar and has passed stays as a meeting that happened (NEED-1764 A).
+        const past = startsAt !== null && startsAt < now;
+        database
+            .prepare(`UPDATE events SET title = ?, description = ?, location = ?, starts_at = ?, ends_at = ?, timezone = ?,
+           all_day = ?, status = ?, source_deleted_at = ?, event_series_id = coalesce(?, event_series_id), updated_at = ?
+         WHERE id = ?`)
+            .run(cancelled && past ? str(event.title) : str(preferred.title), cancelled && past ? str(event.description) : str(preferred.description), cancelled && past ? str(event.location) : str(preferred.location), cancelled && past ? int(event.starts_at) : int(preferred.starts_at), cancelled && past ? int(event.ends_at) : int(preferred.ends_at), str(preferred.timezone), Number(preferred.all_day), cancelled ? (past ? str(event.status) : "cancelled") : String(preferred.status), cancelled && past ? (int(event.source_deleted_at) ?? now) : null, series ? int(series.event_series_id) : null, now, eventId);
+    };
+    const refreshSeries = (seriesId, now) => {
+        const preferred = database
+            .prepare("SELECT * FROM calendar_entries WHERE event_series_id = ? AND deleted_at IS NULL " +
+            "ORDER BY coalesce(external_updated_at, updated_at) DESC, id DESC LIMIT 1")
+            .get(seriesId);
+        if (preferred)
+            database
+                .prepare("UPDATE event_series SET title = ?, recurrence = ?, updated_at = ? WHERE id = ?")
+                .run(str(preferred.title), str(preferred.recurrence), now, seriesId);
+    };
+    const saveParticipants = (entryId, participants, now) => {
+        const kept = new Set();
+        const upsert = database.prepare(`INSERT INTO calendar_entry_participants (entry_id, identity_id, email, name, response, optional, organizer, self,
+         resource, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT (entry_id, email) DO UPDATE SET identity_id = excluded.identity_id, name = excluded.name,
+         response = excluded.response, optional = excluded.optional, organizer = excluded.organizer,
+         self = excluded.self, resource = excluded.resource, updated_at = excluded.updated_at`);
+        for (const one of participants) {
+            const email = addressOf(one.email);
+            if (!email || kept.has(email))
+                continue;
+            kept.add(email);
+            upsert.run(entryId, one.resource ? null : contactOf(context, email, one.name), email, one.name ?? null, one.response ?? null, flag(one.optional), flag(one.organizer), flag(one.self), flag(one.resource), now, now);
+        }
+        const stale = database
+            .prepare("SELECT email FROM calendar_entry_participants WHERE entry_id = ?")
+            .all(entryId)
+            .map((row) => String(row.email))
+            .filter((email) => !kept.has(email));
+        const drop = database.prepare("DELETE FROM calendar_entry_participants WHERE entry_id = ? AND email = ?");
+        for (const email of stale)
+            drop.run(entryId, email);
+    };
+    /** Rules 1 and 2: the row this entry already is, if any. */
+    const existingFor = (calendarId, input, seriesEntryId) => {
+        const same = database
+            .prepare("SELECT * FROM calendar_entries WHERE calendar_id = ? AND external_id = ?")
+            .get(calendarId, input.externalId);
+        if (same || input.kind !== "occurrence" || input.originalStartsAt == null)
+            return same;
+        if (seriesEntryId !== null)
+            return database
+                .prepare("SELECT * FROM calendar_entries WHERE series_entry_id = ? AND original_starts_at = ?")
+                .get(seriesEntryId, input.originalStartsAt);
+        return database
+            .prepare("SELECT * FROM calendar_entries WHERE calendar_id = ? AND series_entry_id IS NULL AND original_starts_at = ? " +
+            "AND json_extract(metadata, '$.recurring_event_id') = ?")
+            .get(calendarId, input.originalStartsAt, 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 series = input.kind === "occurrence" && input.seriesExternalId
+            ? database
+                .prepare("SELECT * FROM calendar_entries WHERE calendar_id = ? AND external_id = ? AND kind = 'series'")
+                .get(calendarId, input.seriesExternalId)
+            : undefined;
+        const seriesEntryId = series ? Number(series.id) : null;
+        const joinUrl = joinUrlWithoutQuery(input.joinUrl);
+        const values = {
+            kind: input.kind,
+            series_entry_id: seriesEntryId,
+            external_id: input.externalId,
+            ical_uid: input.icalUid ?? null,
+            original_starts_at: input.originalStartsAt ?? null,
+            exception: flag(input.exception),
+            status: input.status,
+            title: calendarText(input.title, { dropSecretLines: false }),
+            description: calendarText(input.description),
+            location: calendarText(input.location),
+            starts_at: input.startsAt ?? null,
+            ends_at: input.endsAt ?? null,
+            all_day: flag(input.allDay),
+            start_date: input.startDate ?? null,
+            end_date: input.endDate ?? null,
+            timezone: input.timezone ?? null,
+            recurrence: toJson(input.recurrence ?? null),
+            recurrence_ends_at: input.recurrenceEndsAt ?? null,
+            event_type: input.eventType ?? null,
+            transparency: input.transparency ?? null,
+            visibility: input.visibility ?? null,
+            own_response: input.ownResponse ?? null,
+            organizer_identity_id: input.organizer ? contactOf(context, input.organizer.email, input.organizer.name) : null,
+            join_url: joinUrl,
+            join_key: joinUrl ? (joinKeyOf(joinUrl) ?? "") : null,
+            conference: input.conference ?? null,
+            // The calendar's own page of the event names it in the query (`eid`), which opens nothing on its own.
+            url: input.url ?? null,
+            sequence: input.sequence ?? null,
+            etag: input.etag ?? null,
+            external_updated_at: input.externalUpdatedAt ?? null,
+            metadata: toJson({
+                ...entryMetadata(input.metadata),
+                ...(input.kind === "occurrence" && input.seriesExternalId
+                    ? { recurring_event_id: input.seriesExternalId }
+                    : {}),
+            }),
+            seen_at: now,
+            deleted_at: null,
+        };
+        const found = existingFor(calendarId, input, seriesEntryId);
+        let id;
+        if (found) {
+            id = Number(found.id);
+            if (TRACKED.some((key) => found[key] !== values[key]))
+                database
+                    .prepare(`INSERT INTO calendar_entry_revisions (entry_id, title, starts_at, ends_at, location, status, recurrence,
+               recurrence_ends_at, external_updated_at, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                    .run(id, str(found.title), int(found.starts_at), int(found.ends_at), str(found.location), str(found.status), str(found.recurrence), int(found.recurrence_ends_at), int(found.external_updated_at), now);
+            // Rule 2 found the slot's row under another id; rule 1 found none under this one, so it is free to take.
+            database
+                .prepare(`UPDATE calendar_entries SET ${Object.keys(values)
+                .map((key) => `${key} = ?`)
+                .join(", ")}, updated_at = ? WHERE id = ?`)
+                .run(...Object.values(values), now, id);
+        }
+        else {
+            const columns = Object.keys(values);
+            id = Number(database
+                .prepare(`INSERT INTO calendar_entries (calendar_id, ${columns.join(", ")}, created_at, updated_at)
+             VALUES (?, ${columns.map(() => "?").join(", ")}, ?, ?) RETURNING id`)
+                .get(calendarId, ...Object.values(values), now, now)?.id);
+        }
+        if (input.participants)
+            saveParticipants(id, input.participants, now);
+        if (input.kind === "series")
+            database
+                .prepare("UPDATE calendar_entries SET series_entry_id = ?, updated_at = ? WHERE calendar_id = ? AND kind = 'occurrence' " +
+                "AND series_entry_id IS NULL AND json_extract(metadata, '$.recurring_event_id') = ?")
+                .run(id, now, calendarId, input.externalId);
+        return entryOf(entryRow(id));
+    };
+    /** A series cancelled at the provider cancels its occurrences: past ones stay as history, future ones cancel. */
+    const cancelOccurrences = (series, now) => {
+        const occurrences = database
+            .prepare("SELECT * FROM calendar_entries WHERE series_entry_id = ? AND status <> 'cancelled' AND deleted_at IS NULL")
+            .all(series.id);
+        for (const row of occurrences) {
+            database
+                .prepare(`INSERT INTO calendar_entry_revisions (entry_id, title, starts_at, ends_at, location, status, recurrence,
+             recurrence_ends_at, external_updated_at, created_at) VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, ?, ?)`)
+                .run(Number(row.id), str(row.title), int(row.starts_at), int(row.ends_at), str(row.location), str(row.status), int(row.external_updated_at), now);
+            database
+                .prepare("UPDATE calendar_entries SET status = 'cancelled', updated_at = ? WHERE id = ?")
+                .run(now, Number(row.id));
+        }
+    };
+    return {
+        saveCalendars: async (accountId, calendars, now) => write(database, () => {
+            const upsert = database.prepare(`INSERT INTO calendars (account_id, external_id, title, timezone, access_role, primary_calendar, synced, seen_at,
+             created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT (account_id, external_id) DO UPDATE SET title = excluded.title, timezone = excluded.timezone,
+             access_role = excluded.access_role, primary_calendar = excluded.primary_calendar, seen_at = excluded.seen_at,
+             deleted_at = NULL, updated_at = excluded.updated_at
+           RETURNING *`);
+            return calendars.map((one) => calendarOf(upsert.get(accountId, one.externalId, one.title, one.timezone, one.accessRole, flag(one.primary), flag(one.accessRole === "owner"), now, now, now)));
+        }),
+        calendars: async (accountId) => database
+            .prepare("SELECT * FROM calendars WHERE account_id = ? ORDER BY primary_calendar DESC, title, id")
+            .all(accountId)
+            .map(calendarOf),
+        setCalendarSynced: async (calendarId, synced, now) => write(database, () => {
+            calendarRow(calendarId);
+            database
+                .prepare("UPDATE calendars SET synced = ?, updated_at = ? WHERE id = ?")
+                .run(flag(synced), now, calendarId);
+        }),
+        saveEntries: async (calendarId, entries, now) => write(database, () => {
+            calendarRow(calendarId);
+            // A series first, so an occurrence in the same page finds it.
+            const ordered = [...entries].sort((a, b) => Number(b.kind === "series") - Number(a.kind === "series"));
+            const ids = new Map();
+            const saved = ordered.map((input) => {
+                const entry = saveEntry(calendarId, input, now);
+                ids.set(input, entry.id);
+                return entry;
+            });
+            for (const entry of saved)
+                if (entry.kind === "series" && entry.status === "cancelled")
+                    cancelOccurrences(entry, now);
+            const current = saved.map(({ id }) => entryOf(entryRow(id)));
+            for (const entry of current)
+                link(entry, now);
+            const touched = database
+                .prepare(`SELECT DISTINCT ce.event_id, ce.event_series_id FROM calendar_entries ce
+              WHERE ce.id IN (SELECT value FROM json_each(?)) OR ce.series_entry_id IN (SELECT value FROM json_each(?))`)
+                .all(JSON.stringify(current.map(({ id }) => id)), JSON.stringify(current.map(({ id }) => id)));
+            for (const row of touched) {
+                if (row.event_series_id != null)
+                    refreshSeries(Number(row.event_series_id), now);
+                if (row.event_id != null)
+                    refreshEvent(Number(row.event_id), now);
+            }
+            return entries.map((input) => entryOf(entryRow(ids.get(input))));
+        }),
+        markUnseen: async (calendarId, seenBefore, window, now) => write(database, () => database
+            .prepare(`UPDATE calendar_entries SET deleted_at = ?, updated_at = ? WHERE calendar_id = ? AND deleted_at IS NULL
+                 AND (seen_at IS NULL OR seen_at < ?)
+                 AND (kind <> 'occurrence' OR exception = 1 OR (original_starts_at >= ? AND original_starts_at < ?))`)
+            .run(now, now, calendarId, seenBefore, window.from, window.to).changes),
+        events: async (filter = {}) => {
+            const clauses = ["e.deleted_at IS NULL"];
+            const params = [];
+            const entries = (extra) => `EXISTS (SELECT 1 FROM calendar_entries ce JOIN calendars c ON c.id = ce.calendar_id WHERE ce.event_id = e.id AND ${extra})`;
+            if (filter.from !== undefined) {
+                clauses.push("coalesce(e.ends_at, e.starts_at + 1) > ?");
+                params.push(filter.from);
+            }
+            if (filter.to !== undefined) {
+                clauses.push("e.starts_at < ?");
+                params.push(filter.to);
+            }
+            if (filter.calendarId !== undefined) {
+                clauses.push(entries("ce.calendar_id = ?"));
+                params.push(filter.calendarId);
+            }
+            if (filter.accountId !== undefined) {
+                clauses.push(entries("c.account_id = ?"));
+                params.push(filter.accountId);
+            }
+            if (filter.personId !== undefined) {
+                clauses.push(entries("EXISTS (SELECT 1 FROM calendar_entry_participants p JOIN identity_links il ON il.identity_id = p.identity_id " +
+                    "WHERE p.entry_id = ce.id AND il.person_id = ?)"));
+                params.push(filter.personId);
+            }
+            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");
+            return database
+                .prepare(`SELECT e.* FROM events e WHERE ${clauses.join(" AND ")} ORDER BY e.starts_at, e.id LIMIT ? OFFSET ?`)
+                .all(...params, limit, offset)
+                .map(eventOf);
+        },
+        event: async (id) => read(database, () => {
+            const row = database.prepare("SELECT * FROM events WHERE id = ?").get(id);
+            if (!row)
+                return null;
+            const entries = database
+                .prepare("SELECT * FROM calendar_entries WHERE event_id = ? ORDER BY id")
+                .all(id)
+                .map(entryOf);
+            const ids = JSON.stringify(entries.map((entry) => entry.id));
+            return {
+                event: eventOf(row),
+                entries,
+                participants: database
+                    .prepare("SELECT * FROM calendar_entry_participants WHERE entry_id IN (SELECT value FROM json_each(?)) ORDER BY entry_id, email")
+                    .all(ids)
+                    .map(participantOf),
+                revisions: database
+                    .prepare("SELECT * FROM calendar_entry_revisions WHERE entry_id IN (SELECT value FROM json_each(?)) ORDER BY created_at, id")
+                    .all(ids)
+                    .map(revisionOf),
+            };
+        }),
+        linkEntry: async (entryId, eventId, now) => write(database, () => {
+            const row = database.prepare("SELECT * FROM calendar_entries WHERE id = ?").get(entryId);
+            if (!row)
+                throw new CliError("not_found", `no calendar entry ${entryId} in the local store`);
+            const entry = entryOf(row);
+            const table = entry.kind === "series" ? "event_series" : "events";
+            if (!database.prepare(`SELECT 1 FROM ${table} WHERE id = ?`).get(eventId))
+                throw new CliError("not_found", `no ${entry.kind === "series" ? "event series" : "event"} ${eventId}`);
+            setEntity(entry, eventId, "owner", "owner", now);
+            if (entry.kind !== "series")
+                refreshEvent(eventId, now);
+        }),
+        unlinkEntry: async (entryId, now) => write(database, () => {
+            const row = database.prepare("SELECT * FROM calendar_entries WHERE id = ?").get(entryId);
+            if (!row)
+                throw new CliError("not_found", `no calendar entry ${entryId} in the local store`);
+            const entry = entryOf(row);
+            const column = entry.kind === "series" ? "event_series_id" : "event_id";
+            database.prepare(`UPDATE calendar_entries SET ${column} = NULL, updated_at = ? WHERE id = ?`).run(now, entryId);
+            logLink(database, {
+                type: "calendar_entry",
+                id: entryId,
+                entity: entry.kind === "series" ? "event_series" : "event",
+                from: entry.kind === "series" ? entry.eventSeriesId : entry.eventId,
+                to: null,
+                method: "owner",
+                author: "owner",
+                now,
+            });
+        }),
+        reviews: async (filter = {}) => database
+            .prepare(`SELECT * FROM link_reviews${filter.status ? " WHERE status = ?" : ""} ORDER BY created_at, id`)
+            .all(...(filter.status ? [filter.status] : []))
+            .map(reviewOf),
+        resolveReview: async (id, decision, now) => write(database, () => {
+            const row = database.prepare("SELECT * FROM link_reviews WHERE id = ?").get(id);
+            if (!row)
+                throw new CliError("not_found", `no review ${id} in the local store`);
+            const review = reviewOf(row);
+            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 (chosen !== null && review.linkableType === "calendar_entry") {
+                setEntity(entryOf(entryRow(review.linkableId)), chosen, "owner", "owner", now);
+                if (review.entityType === "event")
+                    refreshEvent(chosen, now);
+            }
+            if (chosen !== null && review.linkableType === "meeting") {
+                database
+                    .prepare("UPDATE meetings SET event_id = ?, updated_at = ? WHERE id = ?")
+                    .run(chosen, now, review.linkableId);
+                logLink(database, {
+                    type: "meeting",
+                    id: review.linkableId,
+                    entity: "event",
+                    from: null,
+                    to: chosen,
+                    method: "owner",
+                    author: "owner",
+                    now,
+                });
+            }
+            if (chosen !== null && review.linkableType === "file") {
+                // The document made for the file while the choice was open goes when nothing else holds it.
+                const file = database.prepare("SELECT document_id FROM files WHERE id = ?").get(review.linkableId);
+                const made = file?.document_id == null ? null : Number(file.document_id);
+                database
+                    .prepare("UPDATE files SET document_id = ?, updated_at = ? WHERE id = ?")
+                    .run(chosen, now, review.linkableId);
+                logFileLink(database, now, review.linkableId, made, chosen, "owner", "owner");
+                if (made !== null && made !== chosen)
+                    database
+                        .prepare("UPDATE documents SET deleted_at = ?, updated_at = ? WHERE id = ? AND deleted_at IS NULL AND NOT EXISTS " +
+                        "(SELECT 1 FROM files WHERE document_id = ? AND deleted_at IS NULL)")
+                        .run(now, now, made, made);
+            }
+            if (chosen === null && review.linkableType === "calendar_entry") {
+                const entry = entryOf(entryRow(review.linkableId));
+                setEntity(entry, newEntity(entry, now), "owner", "owner", now);
+            }
+            if (chosen === null && review.linkableType === "meeting") {
+                const event = Number(database
+                    .prepare(`INSERT INTO events (title, description, location, starts_at, ends_at, timezone, origin, created_at, updated_at)
+                 SELECT title, description, location, started_at, ended_at, timezone, 'auto', ?, ? FROM meetings WHERE id = ?
+                 RETURNING id`)
+                    .get(now, now, review.linkableId)?.id);
+                database
+                    .prepare("UPDATE meetings SET event_id = ?, updated_at = ? WHERE id = ?")
+                    .run(event, now, review.linkableId);
+                logLink(database, {
+                    type: "meeting",
+                    id: review.linkableId,
+                    entity: "event",
+                    from: null,
+                    to: event,
+                    method: "owner",
+                    author: "owner",
+                    now,
+                });
+            }
+            database
+                .prepare("UPDATE link_reviews SET status = ?, chosen_id = ?, decided_by = 'owner', decided_at = ?, updated_at = ? WHERE id = ?")
+                .run(chosen === null ? "apart" : "linked", chosen, now, now, id);
+            return reviewOf(database.prepare("SELECT * FROM link_reviews WHERE id = ?").get(id));
+        }),
+    };
+};

package/dist/store/sqlite/catalog.js

@@ -2,6 +2,7 @@ import { CliError } from "@wirecat/cli-base";
 import { defineQuery, validateQuery, walkQuery } from "@wirecat/cli-base/query";
 import { normalizeTag } from "../../domain/tags.js";
 import { fold } from "../normalize.js";
+import { syncFile } from "./files.js";
 import { queryFilter } from "./query-filter.js";
 import { canonicalTagNamed } from "./tags.js";
 import { write } from "./transaction.js";
@@ -169,6 +170,9 @@ export const catalogStoreOver = ({ database, now }) => {
                             .prepare("INSERT INTO documents(account_id,external_id,kind,title,url,mime,size,external_created_at,external_updated_at,metadata,front_matter,created_at,updated_at) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?)")
                             .run(id, input.externalId, input.kind, input.name, input.url ?? null, input.mime ?? null, input.size ?? null, created, modified, JSON.stringify(metadata), JSON.stringify(frontMatter), at, at);
                 }
+                const written = database.prepare("SELECT id FROM documents WHERE account_id = ? AND external_id = ?");
+                for (const { input } of checked)
+                    syncFile(database, at, Number(written.get(id, input.externalId)?.id));
             });
         },
         reconcile: async (accountId, externalIds) => {
@@ -176,10 +180,17 @@ export const catalogStoreOver = ({ database, now }) => {
             if (externalIds.length > 10000)
                 throw new CliError("validation_error", "catalog scope exceeds 10000 entries");
             const current = [...new Set(externalIds.map((key) => field(key)))];
-            return write(database, () => database
-                .prepare("UPDATE documents SET metadata=json_set(metadata, '$.catalog.active', json('false')) WHERE account_id=? AND json_type(metadata, '$.catalog')='object' AND json_extract(metadata, '$.catalog.active')=1" +
-                (current.length ? " AND external_id NOT IN (SELECT value FROM json_each(?))" : ""))
-                .run(...(current.length ? [id, JSON.stringify(current)] : [id])).changes);
+            return write(database, () => {
+                const retired = database
+                    .prepare("UPDATE documents SET metadata=json_set(metadata, '$.catalog.active', json('false')) WHERE account_id=? AND json_type(metadata, '$.catalog')='object' AND json_extract(metadata, '$.catalog.active')=1" +
+                    (current.length ? " AND external_id NOT IN (SELECT value FROM json_each(?))" : "") +
+                    " RETURNING id")
+                    .all(...(current.length ? [id, JSON.stringify(current)] : [id]));
+                const at = now();
+                for (const row of retired)
+                    syncFile(database, at, Number(row.id), { seen: false });
+                return retired.length;
+            });
         },
         get: async (accountId, externalId, includeInactive = false) => {
             const id = account(accountId);
@@ -205,7 +216,7 @@ export const catalogStoreOver = ({ database, now }) => {
                 params.push(...values);
             };
             const actorSql = "json_each(d.metadata, '$.catalog.folded.people')";
-            const tagSql = "SELECT 1 FROM taggings g JOIN tags t ON t.id=g.tag_id WHERE g.taggable_type='document' AND g.taggable_id=d.id AND t.name=?";
+            const tagSql = "SELECT 1 FROM taggings g JOIN resolved_tags t ON t.id=g.tag_id WHERE g.taggable_type='document' AND g.taggable_id=d.id AND t.name=?";
             const tag = (name) => canonicalTagNamed(database, name)?.name ?? normalizeTag(name);
             if (query.parent !== undefined)
                 add("EXISTS(SELECT 1 FROM json_each(d.metadata, '$.catalog.parents') WHERE value=?)", query.parent);

package/dist/store/sqlite/chat-rekey.js

@@ -127,7 +127,7 @@ const absorb = (context, kept, gone) => {
         "member_stays",
         "member_counts",
         "member_observations",
-        "auto_tag_claims",
+        "canonical_auto_tag_claims",
     ])
         database.prepare(`UPDATE OR IGNORE ${table} SET chat_id = ? WHERE chat_id = ?`).run(kept, gone);
     // Moved members fire no insert trigger, so the chat's involvements are queued by hand.