@wirecat/cli-core 0.488.0 → 0.490.0

package/dist/meetings/testing/event-store-contract.js

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import { eventChange } from "../event-store.js";
 const HOUR = 3_600_000;
 /** "Now" in every case: entries before it have happened. */
 export const CONTRACT_NOW = 1_000 * HOUR;
@@ -218,6 +219,119 @@ export const eventStoreContract = (make) => {
             assert.equal((await store.event(kept?.eventId))?.entries[0]?.deletedAt, null);
             assert.equal((await store.event(far?.eventId))?.entries[0]?.deletedAt, null);
         }),
+        test("a full list marks nothing outside its window: a single, a moved slot, a series that ended", async ({ store, calendar, }) => {
+            const month = 30 * 24 * HOUR;
+            const until = new Date(earlier - month).toISOString().replace(/[-:]|\.\d{3}/gu, "");
+            await store.saveEntries(calendar, [
+                single("old", earlier - month),
+                single("next", later + month),
+                single("inside", later),
+                single("ended", earlier - 2 * month, { kind: "series", recurrence: [`RRULE:FREQ=WEEKLY;UNTIL=${until}`] }),
+                single("endless", earlier - 2 * month, { kind: "series", recurrence: ["RRULE:FREQ=WEEKLY"] }),
+                single("moved", earlier - month, {
+                    kind: "occurrence",
+                    exception: true,
+                    seriesExternalId: "endless",
+                    originalStartsAt: earlier - month,
+                }),
+            ], 2);
+            assert.equal(await store.markUnseen(calendar, 10, { from: earlier, to: later + 24 * HOUR }, 11), 2);
+            const deleted = async (id) => (await store.entry(calendar, id))?.deletedAt;
+            assert.deepEqual(await Promise.all(["old", "next", "ended", "moved", "inside", "endless"].map(deleted)), [
+                null,
+                null,
+                null,
+                null,
+                11,
+                11,
+            ]);
+        }),
+        test("entries marked outside the window of the list that marked them come back, with their events", async ({ store, calendar, }) => {
+            const month = 30 * 24 * HOUR;
+            const [old, next, inside] = await store.saveEntries(calendar, [single("old", earlier - month), single("next", later + month), single("inside", later)], 2);
+            assert.equal(await store.markUnseen(calendar, 10, { from: 0, to: later + 2 * month }, 11), 3);
+            assert.equal((await store.event(next?.eventId))?.event.status, "cancelled");
+            assert.equal(await store.restoreUnseen(calendar, () => ({ from: earlier, to: later + 24 * HOUR }), 12), 2);
+            const oldEvent = (await store.event(old?.eventId))?.event;
+            const nextEvent = (await store.event(next?.eventId))?.event;
+            assert.equal(oldEvent?.sourceDeletedAt, null);
+            assert.equal(nextEvent?.status, "confirmed");
+            assert.equal((await store.entry(calendar, "old"))?.deletedAt, null);
+            assert.equal((await store.entry(calendar, "inside"))?.deletedAt, 11);
+            assert.equal(await store.restoreUnseen(calendar, () => ({ from: earlier, to: later + 24 * HOUR }), 13), 0);
+            assert.equal((await store.event(inside?.eventId))?.event.status, "cancelled");
+        }),
+        test("a list by time finds a long event that started well before it, timed or all-day", async ({ store, calendar, }) => {
+            const day = 24 * HOUR;
+            await store.saveEntries(calendar, [
+                single("trip", later - 30 * day, { endsAt: later + 30 * day }),
+                single("leave", later - 30 * day, {
+                    allDay: true,
+                    startDate: new Date(later - 30 * day).toISOString().slice(0, 10),
+                    endDate: new Date(later + 30 * day).toISOString().slice(0, 10),
+                    endsAt: later + 30 * day,
+                }),
+                single("today", later),
+            ], 2);
+            const day0 = new Date(later).toISOString().slice(0, 10);
+            const day1 = new Date(later + day).toISOString().slice(0, 10);
+            for (const filter of [
+                { from: later, to: later + day },
+                { from: later, to: later + day, fromDate: day0, toDate: day1 },
+            ])
+                assert.deepEqual((await store.events(filter)).map(({ title }) => title).length, 3, JSON.stringify(filter));
+        }),
+        test("a list of changes since an instant finds events new, moved or cancelled since, and says which", async ({ store, calendar, }) => {
+            await store.saveEntries(calendar, ["same", "moved", "back", "cancelled"].map((id) => single(id, later)), 2);
+            await store.saveEntries(calendar, [
+                single("moved", later + HOUR),
+                single("back", later + HOUR),
+                single("cancelled", later, { status: "cancelled" }),
+                single("new", later),
+            ], 10);
+            await store.saveEntries(calendar, [single("back", later)], 11);
+            const changed = async (since) => {
+                const events = await store.events({ changedSince: since });
+                const { entries, revisions } = await store.historyOf(events.map(({ id }) => id), [calendar], since);
+                return Object.fromEntries(events.map((event) => {
+                    const [copy] = entries.filter(({ eventId }) => eventId === event.id);
+                    return [
+                        copy?.externalId,
+                        eventChange(event, entries.filter(({ eventId }) => eventId === event.id), revisions, since),
+                    ];
+                }));
+            };
+            assert.deepEqual(await changed(5), {
+                moved: { change: "moved", at: 10, was: { startsAt: later, endsAt: later + HOUR } },
+                cancelled: { change: "cancelled", at: 10 },
+                new: { change: "new", at: 10 },
+            });
+            assert.deepEqual(Object.keys(await changed(12)), []);
+            assert.equal((await changed(1)).same?.change, "new");
+        }),
+        test("a list of overlapping events holds timed events that clash and take the owner's time", async ({ store, calendar, }) => {
+            const at = later;
+            await store.saveEntries(calendar, [
+                single("first", at),
+                single("second", at + HOUR / 2),
+                single("alone", at + 3 * HOUR),
+                single("declined", at + 3 * HOUR + HOUR / 2, { ownResponse: "declined" }),
+                single("busy", at + 5 * HOUR),
+                single("free", at + 5 * HOUR, { transparency: "transparent" }),
+                single("cancelled", at + 3 * HOUR, { status: "cancelled" }),
+                single("all-day", at, {
+                    allDay: true,
+                    startDate: new Date(at).toISOString().slice(0, 10),
+                    endDate: new Date(at + 24 * HOUR).toISOString().slice(0, 10),
+                    endsAt: at + 24 * HOUR,
+                }),
+            ], 2);
+            const found = await store.events({ overlapping: true, from: at - HOUR, to: at + 8 * HOUR });
+            assert.deepEqual(found.map(({ title }) => title).length, 2);
+            const ids = new Set(found.map(({ id }) => id));
+            for (const externalId of ["first", "second"])
+                assert.ok(ids.has((await store.entry(calendar, externalId))?.eventId), externalId);
+        }),
         test("participants are kept by address; a room is listed and is no contact", async ({ store, calendar }) => {
             const [entry] = await store.saveEntries(calendar, [
                 single("a", later, {

package/dist/store/drivers/node-sqlite.d.ts

@@ -9,4 +9,12 @@ export declare const openWithNodeSqlite: (path: string) => Promise<CacheDatabase
 export declare const nodeClient: (path: string, { readOnly }?: {
     readOnly?: boolean;
 }) => Promise<DatabaseSync>;
-export declare const cacheOverNodeSqlite: (database: DatabaseSync) => CacheDatabase;
+/**
+ * Preparing is the expensive part of a call: the sync write path builds the same SQL text thousands of times, so each
+ * connection keeps its statements, least recently used out first. Node's own `createTagStore` would do it, but it needs
+ * Node 24.9 and template tags, not SQL text. An evicted statement is not finalized, because a caller may still hold
+ * it; `close()` finalizes everything left. The seam must never offer `iterate`: callers share a cached statement, and
+ * reusing a statement invalidates its open iterator.
+ */
+export declare const STATEMENT_CACHE_SIZE = 1000;
+export declare const cacheOverNodeSqlite: (database: DatabaseSync, cacheSize?: number) => CacheDatabase;

package/dist/store/drivers/node-sqlite.js

@@ -19,17 +19,39 @@ export const nodeClient = async (path, { readOnly = false } = {}) => {
         throw error;
     }
 };
-export const cacheOverNodeSqlite = (database) => {
+/**
+ * Preparing is the expensive part of a call: the sync write path builds the same SQL text thousands of times, so each
+ * connection keeps its statements, least recently used out first. Node's own `createTagStore` would do it, but it needs
+ * Node 24.9 and template tags, not SQL text. An evicted statement is not finalized, because a caller may still hold
+ * it; `close()` finalizes everything left. The seam must never offer `iterate`: callers share a cached statement, and
+ * reusing a statement invalidates its open iterator.
+ */
+export const STATEMENT_CACHE_SIZE = 1000;
+export const cacheOverNodeSqlite = (database, cacheSize = STATEMENT_CACHE_SIZE) => {
+    const statements = new Map();
+    const prepare = (sql) => {
+        const statement = database.prepare(sql);
+        return {
+            run: (...parameters) => ({ changes: Number(statement.run(...parameters).changes) }),
+            get: (...parameters) => statement.get(...parameters),
+            all: (...parameters) => statement.all(...parameters),
+        };
+    };
     return {
         exec: (sql) => database.exec(sql),
         prepare: (sql) => {
-            const statement = database.prepare(sql);
-            return {
-                run: (...parameters) => ({ changes: Number(statement.run(...parameters).changes) }),
-                get: (...parameters) => statement.get(...parameters),
-                all: (...parameters) => statement.all(...parameters),
-            };
+            const cached = statements.get(sql);
+            if (cached)
+                statements.delete(sql);
+            const statement = cached ?? prepare(sql);
+            statements.set(sql, statement);
+            if (statements.size > cacheSize)
+                statements.delete(statements.keys().next().value);
+            return statement;
+        },
+        close: () => {
+            statements.clear();
+            database.close();
         },
-        close: () => database.close(),
     };
 };

package/dist/store/sqlite/calendar-events.d.ts

@@ -0,0 +1,4 @@
+import type { Event, EventFilter } from "../../meetings/index.js";
+import type { CacheDatabase } from "../driver.js";
+/** The events of a filter, earliest first (`EventStore.events`). */
+export declare const listEvents: (database: CacheDatabase, filter: EventFilter) => Event[];

package/dist/store/sqlite/calendar-events.js

@@ -0,0 +1,89 @@
+import { CliError } from "@wirecat/cli-base";
+import { eventOf } from "./events.js";
+const DAY = 86_400_000;
+/** The events of a filter, earliest first (`EventStore.events`). */
+export const listEvents = (database, 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})`;
+    const dated = (column, date, instant, at) => {
+        if (at === undefined)
+            return;
+        if (date === undefined) {
+            clauses.push(instant);
+            params.push(at);
+            return;
+        }
+        clauses.push(`(CASE WHEN e.all_day = 1 THEN EXISTS (SELECT 1 FROM calendar_entries ce WHERE ce.event_id = e.id AND ce.${column}) ELSE ${instant} END)`);
+        params.push(date, at);
+    };
+    dated("end_date > ?", filter.fromDate, "coalesce(e.ends_at, e.starts_at + 1) > ?", filter.from);
+    dated("start_date < ?", filter.toDate, "e.starts_at < ?", filter.to);
+    // Bounds on starts_at alone let SQLite seek its index; the CASE above cannot. They are wider than the CASE: by the
+    // longest stored event back, and by a day each way for an all-day event's zone.
+    const longest = () => Number(database.prepare("SELECT coalesce(max(ends_at - starts_at), 0) AS ms FROM events WHERE deleted_at IS NULL").get()
+        ?.ms ?? 0);
+    if (filter.from !== undefined) {
+        clauses.push("e.starts_at >= ?");
+        params.push(filter.from - longest() - DAY);
+    }
+    if (filter.to !== undefined && filter.toDate !== undefined) {
+        clauses.push("e.starts_at < ?");
+        params.push(filter.to + DAY);
+    }
+    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 account = (alias) => {
+        if (filter.accountId === undefined)
+            return "";
+        params.push(filter.accountId);
+        return ` AND ${alias}.account_id = ?`;
+    };
+    if (filter.changedSince !== undefined) {
+        // The SQL form of eventChange: first stored since, cancelled since, or a live copy's time changed since.
+        const since = filter.changedSince;
+        const own = account("c");
+        params.push(since);
+        const older = account("oc");
+        params.push(since, since, since, since);
+        clauses.push(`EXISTS (SELECT 1 FROM calendar_entries ce JOIN calendars c ON c.id = ce.calendar_id WHERE ce.event_id = e.id${own}
+         AND ((ce.created_at >= ? AND NOT EXISTS (SELECT 1 FROM calendar_entries o JOIN calendars oc
+                 ON oc.id = o.calendar_id WHERE o.event_id = e.id${older} AND o.created_at < ?))
+           OR ((e.status = 'cancelled' OR e.source_deleted_at IS NOT NULL) AND (ce.deleted_at >= ?
+             OR (ce.status = 'cancelled' AND EXISTS (SELECT 1 FROM calendar_entry_revisions r WHERE r.entry_id = ce.id
+               AND r.created_at >= ? AND r.status IS NOT 'cancelled'))))
+           OR (ce.deleted_at IS NULL AND ce.status <> 'cancelled' AND (SELECT r.starts_at IS NOT ce.starts_at
+             OR r.ends_at IS NOT ce.ends_at FROM calendar_entry_revisions r WHERE r.entry_id = ce.id AND r.created_at >= ?
+             ORDER BY r.created_at, r.id LIMIT 1) = 1)))`);
+    }
+    if (filter.overlapping) {
+        const busy = (event) => `${event}.deleted_at IS NULL AND ${event}.status <> 'cancelled' AND ${event}.all_day = 0
+         AND ${event}.starts_at IS NOT NULL AND ${event}.ends_at IS NOT NULL AND EXISTS (SELECT 1 FROM calendar_entries
+           bce JOIN calendars bc ON bc.id = bce.calendar_id WHERE bce.event_id = ${event}.id${account("bc")}
+           AND bce.deleted_at IS NULL AND bce.status <> 'cancelled' AND coalesce(bce.own_response, '') <> 'declined'
+           AND coalesce(bce.transparency, '') <> 'transparent')`;
+        const own = busy("e");
+        params.push(longest());
+        clauses.push(`${own} AND EXISTS (SELECT 1 FROM events e2 WHERE e2.id <> e.id AND e2.starts_at < e.ends_at
+         AND e2.ends_at > e.starts_at AND e2.starts_at >= e.starts_at - ? AND ${busy("e2")})`);
+    }
+    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 ${filter.newest ? "e.starts_at DESC, e.id DESC" : "e.starts_at, e.id"} LIMIT ? OFFSET ?`)
+        .all(...params, limit, offset)
+        .map(eventOf);
+};

package/dist/store/sqlite/calendar.js

@@ -1,5 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
-import { calendarText, entryMetadata, joinKeyOf, joinUrlWithoutQuery, } from "../../meetings/index.js";
+import { calendarText, entryInWindow, entryMetadata, joinKeyOf, joinUrlWithoutQuery, } from "../../meetings/index.js";
+import { listEvents } from "./calendar-events.js";
 import { bool, eventOf, fromJson, int, str, toJson } from "./events.js";
 import { driveDocumentOf, driveFileTarget, logFileLink } from "./files.js";
 import { identityOf } from "./identities.js";
@@ -51,6 +52,8 @@ const entryOf = (row) => ({
     etag: str(row.etag),
     seenAt: int(row.seen_at),
     deletedAt: int(row.deleted_at),
+    createdAt: Number(row.created_at),
+    transparency: str(row.transparency),
 });
 const participantOf = (row) => ({
     entryId: Number(row.entry_id),
@@ -79,6 +82,7 @@ const reviewOf = (row) => ({
     id: Number(row.id),
     linkableType: String(row.linkable_type),
     linkableId: Number(row.linkable_id),
+    calendarId: int(row.calendar_id),
     entityType: String(row.entity_type),
     candidates: fromJson(row.candidates),
     reason: String(row.reason),
@@ -94,6 +98,8 @@ const attachmentOf = (row) => ({
     title: str(fromJson(row.metadata)?.title),
     documentId: int(row.to_id),
 });
+const REVIEWS = "SELECT r.*, CASE WHEN r.linkable_type = 'calendar_entry' THEN " +
+    "(SELECT calendar_id FROM calendar_entries WHERE id = r.linkable_id) END AS calendar_id FROM link_reviews r";
 const TRACKED = ["title", "starts_at", "ends_at", "location", "status", "recurrence", "recurrence_ends_at"];
 const flag = (value) => (value ? 1 : 0);
 const cursorKey = (calendarId) => `calendar:${calendarId}`;
@@ -448,6 +454,56 @@ export const eventStoreOver = (context) => {
                 refreshEvent(Number(row.event_id), now);
         }
     };
+    const saveAll = (calendarId, entries, now) => {
+        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.id, now);
+        const current = saved.map(({ id }) => entryOf(entryRow(id)));
+        for (const entry of current)
+            link(entry, now);
+        refreshAround(current.map(({ id }) => id), now);
+        return entries.map((input) => entryOf(entryRow(ids.get(input))));
+    };
+    const removeAll = (calendarId, externalIds, now) => {
+        calendarRow(calendarId);
+        const removed = database
+            .prepare(`SELECT * FROM calendar_entries WHERE calendar_id = ? AND external_id IN (SELECT value FROM json_each(?))
+           AND status <> 'cancelled' AND deleted_at IS NULL`)
+            .all(calendarId, JSON.stringify(externalIds));
+        for (const row of removed) {
+            cancel(row, now);
+            database.prepare("UPDATE calendar_entries SET seen_at = ? WHERE id = ?").run(now, Number(row.id));
+            if (row.kind === "series")
+                cancelOccurrences(Number(row.id), now);
+        }
+        refreshAround(removed.map((row) => Number(row.id)), now);
+        return removed.length;
+    };
+    const putCursor = (calendarId, value, now) => {
+        const accountId = Number(calendarRow(calendarId).account_id);
+        if (value === null)
+            database
+                .prepare("DELETE FROM sync_cursors WHERE account_id = ? AND key = ?")
+                .run(accountId, cursorKey(calendarId));
+        else
+            database
+                .prepare(`INSERT INTO sync_cursors (account_id, key, value, created_at, updated_at) VALUES (?, ?, ?, ?, ?)
+           ON CONFLICT (account_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`)
+                .run(accountId, cursorKey(calendarId), value, now, now);
+    };
+    const slotRows = (calendarId, series, window) => database
+        .prepare(`SELECT * FROM calendar_entries WHERE calendar_id = ? AND kind = 'occurrence' AND series_external_id = ?
+           AND original_starts_at >= ? AND original_starts_at < ? AND deleted_at IS NULL ORDER BY original_starts_at`)
+        .all(calendarId, series, window.from, window.to);
     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,
@@ -468,115 +524,72 @@ export const eventStoreOver = (context) => {
                 .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.id, now);
-            const current = saved.map(({ id }) => entryOf(entryRow(id)));
-            for (const entry of current)
-                link(entry, now);
-            refreshAround(current.map(({ id }) => id), now);
-            return entries.map((input) => entryOf(entryRow(ids.get(input))));
-        }),
-        removeEntries: async (calendarId, externalIds, now) => write(database, () => {
-            calendarRow(calendarId);
-            const removed = database
-                .prepare(`SELECT * FROM calendar_entries WHERE calendar_id = ? AND external_id IN (SELECT value FROM json_each(?))
-               AND status <> 'cancelled' AND deleted_at IS NULL`)
-                .all(calendarId, JSON.stringify(externalIds));
-            for (const row of removed) {
-                cancel(row, now);
-                database.prepare("UPDATE calendar_entries SET seen_at = ? WHERE id = ?").run(now, Number(row.id));
-                if (row.kind === "series")
-                    cancelOccurrences(Number(row.id), now);
-            }
-            refreshAround(removed.map((row) => Number(row.id)), now);
-            return removed.length;
-        }),
+        saveEntries: async (calendarId, entries, now) => write(database, () => saveAll(calendarId, entries, now)),
+        removeEntries: async (calendarId, externalIds, now) => write(database, () => removeAll(calendarId, externalIds, now)),
         markUnseen: async (calendarId, seenBefore, window, now) => write(database, () => {
             const marked = 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 < ?))
-             RETURNING event_id`)
-                .all(now, now, calendarId, seenBefore, window.from, window.to);
+                .prepare(`SELECT * FROM calendar_entries WHERE calendar_id = ? AND deleted_at IS NULL AND (seen_at IS NULL OR seen_at < ?)
+               AND min(coalesce(starts_at, original_starts_at), coalesce(original_starts_at, starts_at)) < ? AND (kind = 'series'
+                 OR max(coalesce(ends_at, 0), coalesce(starts_at, 0) + 1, coalesce(original_starts_at, 0)) >= ?)`)
+                .all(calendarId, seenBefore, window.to, window.from)
+                .filter((row) => entryInWindow(entryOf(row), window));
+            const mark = database.prepare("UPDATE calendar_entries SET deleted_at = ?, updated_at = ? WHERE id = ?");
+            for (const row of marked)
+                mark.run(now, now, Number(row.id));
             for (const eventId of new Set(marked.map((row) => int(row.event_id))))
                 if (eventId !== null)
                     refreshEvent(eventId, now);
             return marked.length;
         }),
+        restoreUnseen: async (calendarId, windowAt, now) => write(database, () => {
+            const restored = database
+                .prepare("SELECT * FROM calendar_entries WHERE calendar_id = ? AND deleted_at IS NOT NULL")
+                .all(calendarId)
+                .map(entryOf)
+                .filter((entry) => !entryInWindow(entry, windowAt(entry.deletedAt)));
+            const restore = database.prepare("UPDATE calendar_entries SET deleted_at = NULL, updated_at = ? WHERE id = ?");
+            for (const { id } of restored)
+                restore.run(now, id);
+            refreshAround(restored.map(({ id }) => id), now);
+            return restored.length;
+        }),
         entry: async (calendarId, externalId) => read(database, () => {
             const row = database
                 .prepare("SELECT * FROM calendar_entries WHERE calendar_id = ? AND external_id = ?")
                 .get(calendarId, externalId);
             return row ? entryOf(row) : null;
         }),
+        slotsOf: async (calendarId, seriesExternalId, window) => read(database, () => slotRows(calendarId, seriesExternalId, window).map(entryOf)),
+        saveSlots: async (calendarId, groups, window, cursor, now) => write(database, () => {
+            let [saved, removed] = [0, 0];
+            const seen = database.prepare("UPDATE calendar_entries SET seen_at = ? WHERE id = ?");
+            for (const { series, slots } of groups) {
+                const held = slotRows(calendarId, series, window);
+                if (slots === null) {
+                    for (const row of held)
+                        seen.run(now, Number(row.id));
+                    continue;
+                }
+                if (slots.length)
+                    saved += saveAll(calendarId, slots, now).length;
+                const given = new Set(slots.map(({ externalId }) => externalId));
+                const stale = held
+                    .filter((row) => Number(row.exception) !== 1 && row.status !== "cancelled" && !given.has(String(row.external_id)))
+                    .map((row) => String(row.external_id));
+                if (stale.length)
+                    removed += removeAll(calendarId, stale, now);
+            }
+            putCursor(calendarId, cursor, now);
+            return { saved, removed };
+        }),
         cursor: async (calendarId) => read(database, () => {
             const { account_id } = calendarRow(calendarId);
             return str(database
                 .prepare("SELECT value FROM sync_cursors WHERE account_id = ? AND key = ?")
                 .get(Number(account_id), cursorKey(calendarId))?.value);
         }),
-        setCursor: async (calendarId, value, now) => write(database, () => {
-            const accountId = Number(calendarRow(calendarId).account_id);
-            if (value === null)
-                database
-                    .prepare("DELETE FROM sync_cursors WHERE account_id = ? AND key = ?")
-                    .run(accountId, cursorKey(calendarId));
-            else
-                database
-                    .prepare(`INSERT INTO sync_cursors (account_id, key, value, created_at, updated_at) VALUES (?, ?, ?, ?, ?)
-               ON CONFLICT (account_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`)
-                    .run(accountId, cursorKey(calendarId), value, now, now);
-        }),
-        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})`;
-            const dated = (column, date, instant, at) => {
-                if (at === undefined)
-                    return;
-                if (date === undefined) {
-                    clauses.push(instant);
-                    params.push(at);
-                    return;
-                }
-                clauses.push(`(CASE WHEN e.all_day = 1 THEN EXISTS (SELECT 1 FROM calendar_entries ce WHERE ce.event_id = e.id AND ce.${column}) ELSE ${instant} END)`);
-                params.push(date, at);
-            };
-            dated("end_date > ?", filter.fromDate, "coalesce(e.ends_at, e.starts_at + 1) > ?", filter.from);
-            dated("start_date < ?", filter.toDate, "e.starts_at < ?", 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 ${filter.newest ? "e.starts_at DESC, e.id DESC" : "e.starts_at, e.id"} LIMIT ? OFFSET ?`)
-                .all(...params, limit, offset)
-                .map(eventOf);
-        },
+        setCursor: async (calendarId, value, now) => write(database, () => putCursor(calendarId, value, now)),
+        events: async (filter = {}) => listEvents(database, filter),
         event: async (id) => read(database, () => {
             const row = database.prepare("SELECT * FROM events WHERE id = ?").get(id);
             if (!row)
@@ -605,6 +618,25 @@ export const eventStoreOver = (context) => {
                     .map(attachmentOf),
             };
         }),
+        historyOf: async (eventIds, calendarIds, since) => read(database, () => {
+            const entries = database
+                .prepare(`SELECT * FROM calendar_entries WHERE event_id IN (SELECT value FROM json_each(?))
+               AND calendar_id IN (SELECT value FROM json_each(?)) ORDER BY id`)
+                .all(JSON.stringify(eventIds), JSON.stringify(calendarIds))
+                .map(entryOf);
+            const revisions = database
+                .prepare(`SELECT * FROM calendar_entry_revisions WHERE entry_id IN (SELECT value FROM json_each(?)) AND created_at >= ?
+              ORDER BY created_at, id`)
+                .all(JSON.stringify(entries.map(({ id }) => id)), since)
+                .map(revisionOf);
+            return { entries, revisions };
+        }),
+        participantsOf: async (eventIds, calendarIds) => read(database, () => database
+            .prepare(`SELECT p.*, ce.event_id FROM calendar_entry_participants p JOIN calendar_entries ce ON ce.id = p.entry_id
+              WHERE ce.event_id IN (SELECT value FROM json_each(?)) AND ce.calendar_id IN (SELECT value FROM json_each(?))
+              ORDER BY ce.event_id, p.entry_id, p.email`)
+            .all(JSON.stringify(eventIds), JSON.stringify(calendarIds))
+            .map((row) => ({ ...participantOf(row), eventId: Number(row.event_id) }))),
         linkEntry: async (entryId, eventId, now) => write(database, () => {
             const row = database.prepare("SELECT * FROM calendar_entries WHERE id = ?").get(entryId);
             if (!row)
@@ -636,11 +668,11 @@ export const eventStoreOver = (context) => {
             });
         }),
         reviews: async (filter = {}) => database
-            .prepare(`SELECT * FROM link_reviews${filter.status ? " WHERE status = ?" : ""} ORDER BY created_at, id`)
+            .prepare(`${REVIEWS}${filter.status ? " WHERE r.status = ?" : ""} ORDER BY r.created_at, r.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);
+            const row = database.prepare(`${REVIEWS} WHERE r.id = ?`).get(id);
             if (!row)
                 throw new CliError("not_found", `no review ${id} in the local store`);
             const review = reviewOf(row);
@@ -710,7 +742,7 @@ export const eventStoreOver = (context) => {
             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));
+            return reviewOf(database.prepare(`${REVIEWS} WHERE r.id = ?`).get(id));
         }),
     };
 };

package/dist/store/sqlite/identities.d.ts

@@ -28,7 +28,7 @@ export declare const people: ({ orm, database }: StoreContext, provider: Provide
 export interface ContactFilter {
     /** Three letters or more of the name, the @username or the local alias. */
     query?: string;
-    /** Text in one of the owner's private notes about them; case folds for Latin letters only, as SQLite's lower(). */
+    /** Three characters or more of one of the owner's private notes about them, anywhere, in any letter case. */
     notes?: string;
 }
 export declare const contacts: ({ orm }: StoreContext, accountKey: number, key: AccountKey, { order, limit, offset, ...filter }: {

package/dist/store/sqlite/identities.js

@@ -2,7 +2,9 @@ import { CliError } from "@wirecat/cli-base";
 import { fold } from "../normalize.js";
 import { and, asc, desc, eq, inArray, isNotNull, isNull, ne, sql } from "./drizzle/core.js";
 import { folded } from "./folded.js";
+import { holdingText } from "./note-index.js";
 import { resolvePersonLinks } from "./person-resolution.js";
+import { bound } from "./query-filter.js";
 import { accountIdentities, accounts, aliases, chatMembers, chats, identities, identityLinkEvents, identityLinks, identityRevisions, messages, persons, } from "./schema.js";
 import { toIso } from "./values.js";
 const flag = (value) => (value === undefined || value === null ? null : Number(value));
@@ -209,13 +211,14 @@ const contactsWhere = (accountKey, key, { query, notes }) => {
     if (query !== undefined && query.trim().length < 3) {
         throw new CliError("validation_error", `a contact search takes at least 3 characters, got "${query}"`);
     }
+    const noted = notes === undefined ? undefined : holdingText("note", "n.id", notes);
     return and(eq(accountIdentities.accountId, accountKey), ne(identities.externalId, key.account), sql `EXISTS (SELECT 1 FROM ${chatMembers} JOIN ${chats} ON ${chats.id} = ${chatMembers.chatId}
                 WHERE ${chatMembers.identityId} = ${identities.id} AND ${chats.accountId} = ${accountIdentities.accountId}
                   AND ${chats.kind} = 'dialog')`, query === undefined
         ? undefined
         : sql `(${identities.id} IN (SELECT rowid FROM identities_fts WHERE identities_fts MATCH ${`"${query.trim().replaceAll('"', '""')}"`}) OR EXISTS (SELECT 1 FROM aliases ca WHERE ca.aliasable_type='identity' AND ca.display=1 AND ca.account_id=${accountKey} AND ca.aliasable_id=${identities.id} AND instr(ca.name_folded, ${fold(query.trim())}) > 0))`, notes === undefined
         ? undefined
-        : sql `EXISTS (SELECT 1 FROM notes n WHERE n.notable_type='identity' AND n.notable_id=${identities.id} AND n.deleted_at IS NULL AND instr(lower(n.body), lower(${notes})) > 0)`);
+        : sql `EXISTS (SELECT 1 FROM notes n WHERE n.notable_type='identity' AND n.notable_id=${identities.id} AND n.deleted_at IS NULL${noted ? sql ` AND ${bound(noted)}` : sql ``})`);
 };
 export const contacts = ({ orm }, accountKey, key, { order, limit, offset = 0, ...filter }) => {
     const byName = [

package/dist/store/sqlite/knowledge.js

@@ -10,6 +10,7 @@ import { ulid } from "../ulid.js";
 import { ownerPerson } from "./actors.js";
 import { linkKind, RELATION_KINDS } from "./link-kinds.js";
 import { meetingProjectsStoreOver } from "./meeting-projects.js";
+import { holdingText } from "./note-index.js";
 import { insertLink, linkOf } from "./notes.js";
 import { queryFilter } from "./query-filter.js";
 import { addTags as addThingTags, canonicalTagNamed, createTag, labelsOf, liveTagging, removeTags as removeThingTags, setMainTopic, } from "./tags.js";
@@ -314,10 +315,11 @@ export const knowledgeStoreOver = (context) => {
             const thing = options.target ? resolve(key, options.target).thing : undefined;
             if (options.target && !thing)
                 return { items: [], hasMore: false };
+            const text = options.search === undefined ? undefined : holdingText("note", "id", options.search);
             const rows = database
                 .prepare("SELECT * FROM notes WHERE deleted_at IS NULL AND (? IS NULL OR (notable_type = ? AND notable_id = ?)) " +
-                "AND (? IS NULL OR instr(lower(body), lower(?)) > 0) ORDER BY created_at DESC, id DESC LIMIT ? OFFSET ?")
-                .all(thing?.type ?? null, thing?.type ?? null, thing?.id ?? null, options.search ?? null, options.search ?? null, limit + 1, offset);
+                `${text ? `AND ${text.sql} ` : ""}ORDER BY created_at DESC, id DESC LIMIT ? OFFSET ?`)
+                .all(thing?.type ?? null, thing?.type ?? null, thing?.id ?? null, ...(text?.params ?? []), limit + 1, offset);
             const items = rows.slice(0, limit).flatMap((row) => annotationOf(row) ?? []);
             return { items, hasMore: rows.length > limit };
         },