@acms-subir/core 0.3.46 → 0.3.48

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # @acms-subir/core
 
+## 0.3.48
+
+### Patch Changes
+
+- 9505051: Moved dates: one date of a repeating event can move to another day, time or room and stay that date, keeping its key, its sign-ups, its hosts and its page. Moving one date used to split it off into a copy.
+
+  **Where staff move a date:**
+
+  - the event editor's new **Single dates** list: the next dates, each with **Move…** (date, times, rooms for that date and a public note), **Cancel date**, and **Move back** or **Restore**. These apply at once, even on a published event, and leave unpublished edits alone;
+  - the Schedule: dragging one date of a series stores a moved date, and in the week view a drag moves by time as well as day (in 15-minute steps, whole series too). **Undo** reverses it, and a moved date's pop-up shows "Moved here from Thu, Jan 10 · 6:00 PM" with **Move back**. When another event, booking or block holds the room at the new time, the toast says so.
+
+  **What follows a moved date:**
+
+  - It comes out at its new time everywhere with its original key and `moved: { from: { start, end }, note }`. It's labelled **Moved** with the old time and the note on the event page ("Moved from Thu, Jan 10 · 6:00 PM."), on `/calendar` and event cards, and on the hosts' My events. The words are in English, Spanish, French, German and Portuguese.
+  - `?on=` finds it by its new day or the day it moved from.
+  - `calendar.ics` and the event's `.ics` get an override (`RECURRENCE-ID` of the old date with the new `DTSTART`), so calendar apps move that one date.
+  - Its RSVPs move with it. Each person with a seat gets a "This date moved" email in their own language, with the note and the button to view or cancel their spot; places in line move quietly. Reminders and "starting soon" go at the new time.
+  - Its room hold moves to the new time, and to the date's own rooms when it moved into others.
+  - The "When an event changes" push rule announces it, keeping the 10-minute merge: "Music class · Moved to Wed, Jan 9, 5:00 PM (was Thu, Jan 10, 6:00 PM)". Moving it back is announced too, and several moved dates are listed by day.
+
+  A date is moved or cancelled, never both. Cancelling a moved date cancels it at its new time and drops the move; a cancelled date must be restored before it can move. Moving the whole series keeps a moved date at its new time, under its new key.
+
+  **API:**
+
+  - `/api/v1/events`, `/api/v1/events/:slug`, `/api/v1/search` and `/api/calendar/events` occurrences carry `moved` (`null` when not moved), and `/api/calendar/events` occurrences also carry their `key`.
+  - Events carry the public `movedDates` (`{ start, end, note }` by original key). Staff callers (an `events:read` API key, the agent tools) also see the date's rooms, place and who moved it. Moves fire the `event.updated` webhook.
+  - New in `@acms-subir/core/server`:
+    - `moveOccurrence(repo, who, eventId, key, { start, end?, roomIds?, location?, note? }, ctx, { quiet? })` and `moveOccurrenceBack(...)`. Both check who is acting: staff ("Create and edit content") and the new `GOOGLE_SYNC` actor (a calendar sync acting with staff rights) may move any date, and get a room taken at the new time back as `clashes`, a warning. A host of the event may move its dates only while the rooms are free (409 otherwise), and staff (`members.notify`, else the owners) are emailed "Date moved".
+    - `quiet: true` skips the push and that staff email, for a sync catching up; the RSVP emails still go.
+    - Moving a date to where it already is returns `changed: false` and writes, sends and emails nothing, so a sync can retry safely. Cancelling an already cancelled date, or restoring one that isn't cancelled, is likewise a no-op, now even after the date has passed.
+    - Refusals carry a `code` beside the `status`: `one-off`, `not-a-date`, `started`, `past`, `original-passed`, `bad-time`, `cancelled-event`, `cancelled-date`, `room-taken`. The table is in `npx acms docs calendar`.
+  - Occurrences carry `moved`, calendar views carry `key` and `moved`, and holds follow a moved date's own rooms.
+
+  Migration 66 adds `events.moved_dates`, a column on the events row, so row-level triggers on `events` see moves. It recreates the `event_changes` triggers (from 0.3.46) with it, so a move or move-back sends `event.updated` and the change push through that queue, and a quiet move is recorded as quiet. Moves are included in backups and environment sync. `npx acms docs calendar` has a Moved dates section, and `npx acms docs server` covers the two new functions.
+
+## 0.3.47
+
+### Patch Changes
+
+- 26f2060: The public calendar can be filtered from its address, and speaks the page's language.
+
+  **Filters.** `/calendar?tag=Class` shows only classes, `/calendar?notag=Class&cal=events` shows the Events calendar without them, and `/calendar?room=chapel` shows what happens in a room. `tag` keeps events with any of its tags, `notag` (alias `excludeTag`) leaves them out, `cal` (alias `calendar`) now takes several calendars, and `room` takes room slugs. Each can repeat (`tag=a&tag=b`) or be comma-separated (`tag=a,b`); different filters must all match. Tags keep their rules (a name in any case, or its slug; internal `#` tags never match publicly). Only rooms shown on public events match, and a private calendar or a hidden room answers exactly like one that doesn't exist, so a link can't probe for them. Events from linked feed calendars and "Reserved" booking blocks have no tags: `tag` leaves them out, `notag` keeps them, and a room filter keeps a room's own Reserved blocks.
+
+  On `/calendar` the calendar chips now switch calendars on and off, so several can be picked; tags, left-out tags and rooms show as removable chips with **Clear filters**; and view links, chips and **Subscribe** keep the filters. A filtered page subscribes to `/calendar.ics` with the same filters (one calendar alone keeps its own feed). The same parameters work on `/embed/calendar/<slug|all>` (`cal` adds calendars to the one in the address), `/calendar.ics`, `/calendar/<slug>.ics` (`tag`, `notag`, `room`), `/api/v1/events` (now documented in the OpenAPI document; repeating them is allowed, other parameters still may not repeat) and `/api/calendar/events`, where a key with `events:read` also matches private calendars, every room and `#` tags. An unknown, private or hidden calendar or room is a 404 on the APIs and feeds, and an empty calendar with its chip on the page.
+
+  **Languages.** `/es/calendar` is in Spanish like event pages: the headings, chips, views, Subscribe menu, agenda, empty states, the grid's Today/Upcoming/Details and the dates and time zone. Event titles use their translations, and every link on the page (views, chips, events, cards) stays under `/es`. French, German and Portuguese work the same way. Embeds take `?lang=es` (one of the site's languages). The calendar card ("No calendar connected", "Calendar unavailable right now", "Open in Google Calendar") and event cards ("Untitled event", "No upcoming events") also speak their dates' language.
+
 ## 0.3.46
 
 ### Patch Changes

package/cli/migrations.generated.mjs

@@ -84,24 +84,24 @@ function trigger(name, action, table, when, event, data) {
 function content(kind) {
   const table = `${kind}s`;
   const fields = kind === "post" ? ["collection", "slug", "title", "status", "body", "body_json", "body_html", "excerpt", "tags", "cover", "cover_alt", "seo_title", "seo_desc", "featured", "author_id", "template", "published_at"] : ["slug", "title", "status", "is_home", "locale", "blocks", "body_json", "body_html", "seo_title", "seo_desc", "template"];
-  const snapshot2 = (row) => `json_object('id',${row}.id,'slug',${row}.slug,'title',${row}.title,'status',${row}.status,
+  const snapshot = (row) => `json_object('id',${row}.id,'slug',${row}.slug,'title',${row}.title,'status',${row}.status,
     ${kind === "post" ? `'collection',${row}.collection` : `'locale',${row}.locale,'isHome',json(CASE WHEN ${row}.is_home THEN 'true' ELSE 'false' END)`})`;
-  const changed2 = fields.map((f) => `OLD.${f} IS NOT NEW.${f}`).join(" OR ");
+  const changed = fields.map((f) => `OLD.${f} IS NOT NEW.${f}`).join(" OR ");
   const event = `CASE WHEN OLD.status!='published' THEN '${kind}.published'
     WHEN NEW.status!='published' THEN '${kind}.unpublished' ELSE '${kind}.updated' END`;
   return [
-    trigger(`webhook_${kind}_insert`, "INSERT", table, "NEW.status='published'", `'${kind}.published'`, `json_object('${kind}',${snapshot2("NEW")})`),
+    trigger(`webhook_${kind}_insert`, "INSERT", table, "NEW.status='published'", `'${kind}.published'`, `json_object('${kind}',${snapshot("NEW")})`),
     trigger(
       `webhook_${kind}_update`,
       "UPDATE",
       table,
-      `(OLD.status='published' OR NEW.status='published') AND (${changed2})`,
+      `(OLD.status='published' OR NEW.status='published') AND (${changed})`,
       event,
-      `json_object('${kind}',json(CASE WHEN NEW.status='published' THEN ${snapshot2("NEW")}
-        ELSE json_set(${snapshot2("OLD")},'$.status',NEW.status) END),
-        'previous',json(CASE WHEN OLD.status='published' THEN ${snapshot2("OLD")} ELSE 'null' END))`
+      `json_object('${kind}',json(CASE WHEN NEW.status='published' THEN ${snapshot("NEW")}
+        ELSE json_set(${snapshot("OLD")},'$.status',NEW.status) END),
+        'previous',json(CASE WHEN OLD.status='published' THEN ${snapshot("OLD")} ELSE 'null' END))`
     ),
-    trigger(`webhook_${kind}_delete`, "DELETE", table, "OLD.status='published'", `'${kind}.deleted'`, `json_object('${kind}',${snapshot2("OLD")})`)
+    trigger(`webhook_${kind}_delete`, "DELETE", table, "OLD.status='published'", `'${kind}.deleted'`, `json_object('${kind}',${snapshot("OLD")})`)
   ];
 }
 var media = (row) => `json_object('media',json_object('id',${row}.id,'key',${row}.key,'filename',${row}.filename,
@@ -220,7 +220,7 @@ var ROOM_HOLD_MIGRATION = { version: 41, statements: [
 
 // src/lib/calendar/change-migration.ts
 var now4 = "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
-var EVENT_CHANGE_SNAPSHOT = [
+var V65_SNAPSHOT = [
   "id",
   "slug",
   "title",
@@ -251,7 +251,7 @@ var EVENT_CHANGE_SNAPSHOT = [
   "created_at",
   "updated_at"
 ];
-var EVENT_CHANGE_COLUMNS = [
+var V65_COLUMNS = [
   "slug",
   "title",
   "body_json",
@@ -283,12 +283,25 @@ var EVENT_CHANGE_COLUMNS = [
   "start_at",
   "end_at"
 ];
-var snapshot = (row) => `json_object(${EVENT_CHANGE_SNAPSHOT.map((c) => `'${c}',${row}.${c}`).join(",")})`;
+var EVENT_CHANGE_SNAPSHOT = [...V65_SNAPSHOT, "moved_dates"];
+var EVENT_CHANGE_COLUMNS = [...V65_COLUMNS, "moved_dates"];
+var snapshotOf = (cols, row) => `json_object(${cols.map((c) => `'${c}',${row}.${c}`).join(",")})`;
 var live = "(SELECT suppressed FROM webhook_control WHERE id=1)=0";
 var quiet = "COALESCE((SELECT quiet FROM push_control WHERE id=1),0)";
 var record = (id, before, after) => `INSERT INTO event_changes (event_id,old_row,new_row,quiet,created_at)
   VALUES (${id},${before},${after},${quiet},${now4});`;
-var changed = EVENT_CHANGE_COLUMNS.map((c) => `OLD.${c} IS NOT NEW.${c}`).join(" OR ");
+function eventChangeTriggers(snapshotCols, changedCols) {
+  const changed = changedCols.map((c) => `OLD.${c} IS NOT NEW.${c}`).join(" OR ");
+  return [
+    `CREATE TRIGGER event_changes_insert AFTER INSERT ON events WHEN NEW.status='published' AND ${live}
+    BEGIN ${record("NEW.id", "NULL", snapshotOf(snapshotCols, "NEW"))} END`,
+    `CREATE TRIGGER event_changes_update AFTER UPDATE ON events
+    WHEN (OLD.status='published' OR NEW.status='published') AND (${changed}) AND ${live}
+    BEGIN ${record("NEW.id", snapshotOf(snapshotCols, "OLD"), snapshotOf(snapshotCols, "NEW"))} END`,
+    `CREATE TRIGGER event_changes_delete AFTER DELETE ON events WHEN OLD.status='published' AND ${live}
+    BEGIN ${record("OLD.id", snapshotOf(snapshotCols, "OLD"), "NULL")} END`
+  ];
+}
 var skipped = `CASE WHEN (SELECT suppressed FROM webhook_control WHERE id=1)=1 OR ${quiet}=1 THEN 'skipped' ELSE 'pending' END`;
 var ledger = `INSERT INTO push_queue (key,kind,doc_id,occurrence,status,notification_id,created_at,updated_at)
     SELECT 'event:'||NEW.id,'event',NEW.id,NULL,${skipped},NULL,${now4},${now4}
@@ -302,19 +315,22 @@ var EVENT_CHANGES_MIGRATION = { version: 65, statements: [
   `CREATE INDEX event_changes_event ON event_changes (event_id, claimed_until)`,
   `CREATE TABLE push_control (id INTEGER PRIMARY KEY CHECK(id=1), quiet INTEGER NOT NULL DEFAULT 0)`,
   `INSERT INTO push_control (id,quiet) VALUES (1,0)`,
-  `CREATE TRIGGER event_changes_insert AFTER INSERT ON events WHEN NEW.status='published' AND ${live}
-    BEGIN ${record("NEW.id", "NULL", snapshot("NEW"))} END`,
-  `CREATE TRIGGER event_changes_update AFTER UPDATE ON events
-    WHEN (OLD.status='published' OR NEW.status='published') AND (${changed}) AND ${live}
-    BEGIN ${record("NEW.id", snapshot("OLD"), snapshot("NEW"))} END`,
-  `CREATE TRIGGER event_changes_delete AFTER DELETE ON events WHEN OLD.status='published' AND ${live}
-    BEGIN ${record("OLD.id", snapshot("OLD"), "NULL")} END`,
+  ...eventChangeTriggers(V65_SNAPSHOT, V65_COLUMNS),
   `DROP TRIGGER push_event_insert`,
   `DROP TRIGGER push_event_publish`,
   `CREATE TRIGGER push_event_insert AFTER INSERT ON events WHEN NEW.status='published' BEGIN ${ledger} END`,
   `CREATE TRIGGER push_event_publish AFTER UPDATE OF status ON events
       WHEN NEW.status='published' AND OLD.status IS NOT 'published' BEGIN ${ledger} END`
 ] };
+var MOVED_DATES_MIGRATION = (contentVersionUpdate) => ({ version: 66, statements: [
+  `ALTER TABLE events ADD COLUMN moved_dates TEXT NOT NULL DEFAULT '{}'`,
+  `DROP TRIGGER content_version_events_update`,
+  contentVersionUpdate,
+  `DROP TRIGGER event_changes_insert`,
+  `DROP TRIGGER event_changes_update`,
+  `DROP TRIGGER event_changes_delete`,
+  ...eventChangeTriggers([...V65_SNAPSHOT, "moved_dates"], [...V65_COLUMNS, "moved_dates"])
+] });
 
 // src/lib/maps/migration.ts
 var PLACES_MIGRATION = { version: 43, statements: [
@@ -566,8 +582,8 @@ var CONTENT_VERSION_COLUMNS = {
 };
 var BUMP_CONTENT_VERSION = "UPDATE settings SET content_version = content_version + 1 WHERE id = 1;";
 function contentVersionTriggers(table, columns) {
-  const changed2 = columns.map((c) => `OLD.${c} IS NOT NEW.${c}`).join(" OR ");
-  const update = `CREATE TRIGGER content_version_${table}_update AFTER UPDATE OF ${columns.join(", ")} ON ${table} WHEN ${changed2} BEGIN ${BUMP_CONTENT_VERSION} END`;
+  const changed = columns.map((c) => `OLD.${c} IS NOT NEW.${c}`).join(" OR ");
+  const update = `CREATE TRIGGER content_version_${table}_update AFTER UPDATE OF ${columns.join(", ")} ON ${table} WHEN ${changed} BEGIN ${BUMP_CONTENT_VERSION} END`;
   if (table === "settings") return [update];
   return [
     `CREATE TRIGGER content_version_${table}_insert AFTER INSERT ON ${table} BEGIN ${BUMP_CONTENT_VERSION} END`,
@@ -1247,12 +1263,15 @@ var MIGRATIONS = [
   ] },
   // every change to a published event, from any write path, queued for its
   // side effects (webhooks, "event changed" pushes, slug redirects)
-  EVENT_CHANGES_MIGRATION
+  EVENT_CHANGES_MIGRATION,
+  // single dates of a series moved (CalEvent.movedDates): a column on the
+  // row, so the triggers on events (content version, event_changes) see a move
+  MOVED_DATES_MIGRATION(contentVersionTriggers("events", [...CONTENT_VERSION_COLUMNS.events, "cancelled_dates", "moved_dates"])[2])
 ];
 var CURRENT_CONTENT_VERSION_COLUMNS = {
   ...CONTENT_VERSION_COLUMNS,
   settings: [...CONTENT_VERSION_COLUMNS.settings, "links_verified", "links_avatar_shape", "links_avatar_fit", "links_avatar_scale", "legal"],
-  events: [...CONTENT_VERSION_COLUMNS.events, "cancelled_dates"],
+  events: [...CONTENT_VERSION_COLUMNS.events, "cancelled_dates", "moved_dates"],
   resources: [...CONTENT_VERSION_COLUMNS.resources, "color", "show_on_events"],
   announcements: ANNOUNCEMENT_VISIBLE_COLUMNS
 };

package/docs/calendar.md

@@ -49,6 +49,86 @@ stays listed, struck through as "Cancelled", so nobody wonders where it went:
 
 The keys are stored in `cancelledDates`. `restoreOccurrence` undoes a cancellation.
 
+## Moved dates
+
+One date of a series can move to another day, time or room and stay that same date.
+Its key, its sign-ups, its hosts and its page all stay with it. Ways to move a date:
+
+- the event editor's **Single dates** list: **Move…** (date, times, rooms and a public
+  note), next to **Cancel date**;
+- dragging one date on the Schedule. The week view moves by time as well as day.
+  **Undo** and the date's **Move back** put it back;
+- `moveOccurrence` from site code.
+
+A moved date:
+
+- comes out at its new time everywhere, keeping its original key, with `moved: {
+  from: { start, end }, note }`;
+- is labelled **Moved** with its old time and the note on the event page, `/calendar`,
+  event cards, the app API (`occurrences[].moved`) and the hosts' My events;
+- takes `?on=` with either day: its new one or the one it moved from;
+- is an override in `calendar.ics` (same UID, `RECURRENCE-ID` of the old date, the new
+  `DTSTART`/`DTEND`), so calendar apps move that one date;
+- holds its rooms at the new time: its own `roomIds` when it moved into other rooms,
+  else the event's;
+- takes its RSVPs with it. Their start moves too, and each person with a seat gets the
+  "new time" email in their own language, with the note and the button to view or
+  cancel their spot. Places in line move quietly;
+- gets reminders and "starting soon" notices at the new time;
+- is announced by the "When an event changes" rule, still merged over 10 minutes:
+  "Music class · Moved to Wed, Jan 9, 5:00 PM (was Thu, Jan 10, 6:00 PM)". Moving it
+  back is announced the same way.
+
+A date is moved or cancelled, never both. To move a cancelled date, restore it first.
+Cancelling a moved date cancels it at its new time (its RSVPs too) and drops the move.
+Moving the whole series keeps a moved date at its new time, under its new key.
+
+Moves are stored on the event row as `movedDates`, keyed by the original occurrence key:
+`{ start, end, roomIds?, location?, note, by, at }`, with `start`/`end` in wall-clock
+time like the event's own. There's no per-date title. Public JSON shows `start`, `end`
+and `note`. `by` (who moved it: a user id, or `google-sync`) and `at` are for staff.
+
+### Who can move a date
+
+`moveOccurrence(repo, who, eventId, key, { start, end?, roomIds?, location?, note? }, ctx, { quiet? })`
+and `moveOccurrenceBack(repo, who, eventId, key, ctx, { quiet? })` check who is acting:
+
+- **Staff** with "Create and edit content" may move any date. If another event, booking,
+  block or busy calendar takes the rooms at the new time, the move still happens, and
+  the result's `clashes` lists what else is there.
+- **`GOOGLE_SYNC`** is a calendar sync acting with staff rights. A clash only warns,
+  since the change already happened in Google.
+- **A host of the event** may move its dates while the rooms are free; a taken room
+  refuses the move (409). Staff (`members.notify`, else the owners) are emailed about
+  each move a host makes.
+- Anyone else gets 404, and nobody signed in gets 401.
+
+`end` defaults to the date's own length. `roomIds`, `location` and `note` replace the
+date's own when given, and omitting them keeps what it had. `quiet: true` skips the app
+notice and the staff email, for a sync catching up on changes people already know about.
+The RSVP emails still go, because those people's own sign-ups moved.
+
+Moving a date to exactly where it already is (same times, rooms, place and note), or
+moving back a date that isn't moved, changes nothing and returns `changed: false`: no
+write, webhook, push or email. A sync can retry, or re-apply what it already applied,
+safely. Cancelling a date that's already cancelled, or restoring one that isn't, is a
+no-op too, even after the date has passed.
+
+Errors carry a `status`, a message safe to show people, and a `code`:
+
+| status | code | when |
+|---|---|---|
+| 400 | `one-off` | the event doesn't repeat |
+| 400 | `not-a-date` | the key isn't one of its dates |
+| 400 | `started` | the date has started or passed |
+| 400 | `past` | the new time has passed |
+| 400 | `original-passed` | moving back to a time that has passed |
+| 400 | `bad-time` | the times aren't valid, or don't fit an all-day or timed event |
+| 409 | `cancelled-event` | the whole event is cancelled |
+| 409 | `cancelled-date` | the date is cancelled (restore it first) |
+| 409 | `room-taken` | a host moving into a taken room |
+| 401, 404 | | who is acting |
+
 ## Rooms
 
 Rooms, people and equipment are **Resources** (Admin → Calendar → Rooms; they need

package/docs/server.md

@@ -12,6 +12,7 @@ import {
   getRepo, currentUser,
   listEvents, getEvent, listOccurrences,
   cancelOccurrence, restoreOccurrence,
+  moveOccurrence, moveOccurrenceBack, GOOGLE_SYNC,
   eventRoomClashes, roomBusy,
   listMyEvents, listEventRequests, submitEventRequest, updateEventRequest,
   withdrawEventRequest, approveEventRequest, declineEventRequest, setHostedOccurrence,
@@ -33,6 +34,8 @@ getEvent(repo: Repo, id: string): Promise<CalEvent | null>
 listOccurrences(repo: Repo, w: { eventId?: string; from: Date | number; to: Date | number; tag?: string; excludeTag?: string }): Promise<Occurrence[]>
 cancelOccurrence(repo: Repo, eventId: string, occurrenceKey: string, ctx: WriteContext): Promise<CalEvent>
 restoreOccurrence(repo: Repo, eventId: string, occurrenceKey: string, ctx: WriteContext): Promise<CalEvent>
+moveOccurrence(repo: Repo, who: ServerUser | null | typeof GOOGLE_SYNC, eventId: string, occurrenceKey: string, input: MoveInput, ctx: WriteContext, opts?: { quiet?: boolean }): Promise<MoveResult>
+moveOccurrenceBack(repo: Repo, who: ServerUser | null | typeof GOOGLE_SYNC, eventId: string, occurrenceKey: string, ctx: WriteContext, opts?: { quiet?: boolean }): Promise<MoveResult>
 eventRoomClashes(repo: Repo, event: string | CalEvent, opts?: { horizonDays?: number; now?: Date | number }): Promise<EventClash[]>
 roomBusy(repo: Repo, q: { roomIds: string[]; from: Date | number; to: Date | number; ignore?: { eventId: string; key?: string } }): Promise<BusySlot[]>
 
@@ -48,7 +51,9 @@ setHostedOccurrence(repo: Repo, who: ServerUser | null, eventId: string, occurre
 
 type Role = 'owner' | 'administrator' | 'editor' | 'author' | 'contributor' | (string & {})
 interface ServerUser { id: string; email: string; name: string; role: Role; staff: boolean; can(permission: string): boolean }
-interface Occurrence { event: CalEvent; start: number; end: number; allDay: boolean; days: number; key: string; cancelled: boolean; roomIds: string[] }
+interface Occurrence { event: CalEvent; start: number; end: number; allDay: boolean; days: number; key: string; cancelled: boolean; roomIds: string[]; moved?: { from: { start: number; end: number }; note: string; location?: EventLocation } }
+interface MoveInput { start: string; end?: string; roomIds?: string[]; location?: Partial<EventLocation> | null; note?: string }
+interface MoveResult { event: CalEvent; clashes: BusySlot[]; changed: boolean }
 interface Hold { resourceId: string; eventId: string; key: string; title: string; start: number; end: number; eventStart: number; eventEnd: number }
 interface EventClash { hold: Hold; other: Hold }
 interface BusySlot { resourceId: string; start: number; end: number; kind: 'event' | 'booking' | 'block' | 'calendar'; title: string; eventId?: string; key?: string; bookingId?: string }
@@ -56,8 +61,8 @@ interface WriteContext { url: URL; locals: unknown }
 ```
 
 The types `Repo`, `Role`, `ServerUser`, `CalEvent`, `Occurrence`, `ListEventsOptions`,
-`OccurrenceWindow`, `WriteContext`, `EventRequestInput`, `Hold`, `EventClash` and
-`BusySlot` are exported too.
+`OccurrenceWindow`, `WriteContext`, `EventRequestInput`, `Hold`, `EventClash`,
+`BusySlot`, `MoveInput` and `MoveResult` are exported too.
 
 - **`getRepo(locals)`**: the site's content store for this request. Pass `Astro.locals`
   (or the endpoint/action's `locals`). `Repo` is an opaque handle; pass it to the other
@@ -128,6 +133,26 @@ another day (the admin's drag-to-move), its cancelled dates move with it. If its
 or rule is edited instead, keys that no longer match an occurrence are ignored, not an
 error.
 
+## Moved dates
+
+- **`moveOccurrence(repo, who, eventId, key, input, ctx, opts?)`**: moves one date of a
+  repeating event to `input.start`, wall-clock in the event's timezone (`end` defaults
+  to the date's own length). It applies at once, keeps the date's key, moves its RSVPs
+  (each person is emailed) and its room hold, and shows it as "Moved" with its old time
+  everywhere. It checks `who`: staff ("Create and edit content") and `GOOGLE_SYNC` may
+  move any date, and get what else takes its rooms then in `clashes`. A host of the
+  event may move it only while its rooms are free (409 otherwise), and staff are
+  emailed. `opts.quiet` skips the app notice and that staff email.
+- **`moveOccurrenceBack(...)`**: puts it back where the series has it. Idempotent.
+
+Moving a date to where it already is returns `changed: false` without writing or
+sending anything, so retries are safe. Errors carry `status` and `code` (`one-off`,
+`not-a-date`, `started`, `past`, `bad-time`, `cancelled-date`, `room-taken`…; the
+full table is in `npx acms docs calendar`).
+
+`npx acms docs calendar` has the details: what follows a moved date, how it shows,
+and the error statuses.
+
 ## Rooms
 
 Events hold rooms (`event.roomHold.resourceIds`, the Rooms box in the event editor)

package/docs/theme-authoring.md

@@ -55,7 +55,7 @@ const date = new Intl.DateTimeFormat('en', { dateStyle: 'medium', timeZone: Astr
 </section>}
 ```
 
-`calendarConfig()` returns a fresh `{ enabled, base, eventsBase }` object; `eventUrl(slug)` uses the configured event base. `upcomingEvents(Astro, options?)` resolves storage through `Astro.locals` and loads the site's timezone settings. It returns the next or ongoing occurrence of each distinct published, publicly listed native event, soonest first, including recurring and all-day events. Private/unlisted calendars and external feed entries are excluded; cancelled public events remain visible so templates can label them. `tag` keeps only events with that tag and `excludeTag` leaves them out (a tag's name in any case, or its slug), e.g. `upcomingEvents(Astro, { tag: 'Class' })` for a Classes page. Disabled calendars and a zero limit return `[]` without accessing storage. Storage errors propagate to the template.
+`calendarConfig()` returns a fresh `{ enabled, base, eventsBase }` object; `eventUrl(slug)` uses the configured event base. `upcomingEvents(Astro, options?)` resolves storage through `Astro.locals` and loads the site's timezone settings. It returns the next or ongoing occurrence of each distinct published, publicly listed native event, soonest first, including recurring and all-day events. Private/unlisted calendars and external feed entries are excluded; cancelled public events remain visible so templates can label them, and a date moved to another time carries `moved` (`{ from: { start, end }, note }`) so templates can say "Moved from …". `tag` keeps only events with that tag and `excludeTag` leaves them out (a tag's name in any case, or its slug), e.g. `upcomingEvents(Astro, { tag: 'Class' })` for a Classes page. Disabled calendars and a zero limit return `[]` without accessing storage. Storage errors propagate to the template.
 
 Options default to `{ limit: 6, horizonDays: 400 }`. The limit must be a non-negative safe integer and the horizon a positive finite number. Each `UpcomingEvent` contains `{ event, start, end, allDay, days }`, with start/end in Unix milliseconds. Format occurrence timestamps using the site's timezone rather than the authored `event.start` when displaying recurring events. `UpcomingEvent`, `UpcomingEventsOptions`, and `ThemeCalendarConfig` are exported types.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acms-subir/core",
-  "version": "0.3.46",
+  "version": "0.3.48",
   "publishConfig": {
     "access": "public"
   },

package/src/actions/index.ts

@@ -30,7 +30,9 @@ import { loadFeed } from '../lib/calendar/ics';
 import { NATIVE_ALL } from '../lib/calendar/render';
 import { collectViewEvents } from '../lib/calendar/data';
 import { loadBoard } from '../lib/calendar/board';
-import { cancelOccurrence, duplicateEvent, moveOccurrence, moveSeries, quickCreate, restoreOccurrence, undoMove } from '../lib/calendar/schedule';
+import { cancelOccurrence, duplicateEvent, moveDateBy, moveSeries, quickCreate, restoreOccurrence, undoMove } from '../lib/calendar/schedule';
+import { moveOccurrence, moveOccurrenceBack, upcomingDates } from '../lib/calendar/moves';
+import type { BusySlot } from '../lib/booking/holds';
 import { waitUntilFrom } from '../lib/webhooks';
 import { siteOrigin } from '../lib/seo';
 import type { CalEvent } from '../lib/schema';
@@ -56,6 +58,21 @@ async function requireAdmin(ctx: ActionAPIContext) {
     throw new ActionError({ code: 'UNAUTHORIZED', message: 'Not signed in.' });
   }
 }
+// the person acting, for the rules that check who it is (lib/calendar/moves.ts)
+const actorOf = (access: Awaited<ReturnType<typeof requireCan>>) => ({ id: access.userId, can: (p: string) => access.can(p as Permission) });
+// "Hall is also taken then: Choir · 6:30 – 7:30 PM" ('' when it's free)
+async function clashWarning(repo: Awaited<ReturnType<typeof getRepo>>, clashes: BusySlot[]): Promise<string> {
+  if (!clashes.length) return '';
+  const [settings, resources] = await Promise.all([repo.getSettings(), repo.listResources()]);
+  const names = new Map(resources.map((r) => [r.id, r.name]));
+  const time = new Intl.DateTimeFormat(siteLocale(settings), { hour: 'numeric', minute: '2-digit', timeZone: settings.timezone || 'UTC' });
+  const what = (c: BusySlot) => c.kind === 'calendar' ? 'its busy calendar' : c.kind === 'block' ? `blocked${c.title ? ` (${c.title})` : ''}` : c.title || 'a booking';
+  const first = clashes[0];
+  const more = clashes.length > 1 ? ` and ${clashes.length - 1} more` : '';
+  let range: string;
+  try { range = time.formatRange(first.start, first.end); } catch { range = `${time.format(first.start)} – ${time.format(first.end)}`; }
+  return `${names.get(first.resourceId) ?? 'The room'} is also taken then: ${what(first)} · ${range}${more}. Both keep the room.`;
+}
 // …and that their role grants the permission (Team → Roles)
 async function requireCan(ctx: ActionAPIContext, permission: Permission) {
   const access = await accessFor(ctx.request, ctx.cookies, await getRepo(ctx.locals));
@@ -1134,28 +1151,76 @@ export const server = {
         try { const e = await quickCreate(repo, input, await publishHooks(ctx)); return { id: e.id, status: e.status }; } catch (e) { asActionError(e); }
       },
     }),
-    // Schedule: drag to another day. `occurrence` + mode 'one' moves a single
-    // repeat; otherwise the whole event moves.
+    // Schedule: drag to another day (and, in the week view, another time:
+    // `minutes` more). `occurrence` + mode 'one' moves a single date of a
+    // series (a moved date that keeps its RSVPs); otherwise the whole event
+    // moves. `warning`: what else takes its rooms at the new time.
     move: defineAction({
-      input: z.object({ id: z.string(), days: z.number().int(), mode: z.enum(['series', 'one']).default('series'), occurrence: z.string().max(20).default('') }),
-      handler: async ({ id, days, mode, occurrence }, ctx) => {
-        await requireCan(ctx, 'content.edit');
+      input: z.object({ id: z.string(), days: z.number().int(), minutes: z.number().int().min(-1440).max(1440).default(0), mode: z.enum(['series', 'one']).default('series'), occurrence: z.string().max(20).default('') }),
+      handler: async ({ id, days, minutes, mode, occurrence }, ctx) => {
+        const who = actorOf(await requireCan(ctx, 'content.edit'));
         const repo = await getRepo(ctx.locals);
         try {
-          const r = mode === 'one' ? await moveOccurrence(repo, id, occurrence, days, await publishHooks(ctx)) : await moveSeries(repo, id, days, await publishHooks(ctx));
-          return { id: r.event.id, undo: r.undo };
+          if (mode === 'one') {
+            const r = await moveDateBy(repo, who, id, occurrence, days * 1440 + minutes, await publishHooks(ctx));
+            return { id: r.event.id, undo: r.undo, warning: await clashWarning(repo, r.clashes) };
+          }
+          const r = await moveSeries(repo, id, days, await publishHooks(ctx), minutes);
+          return { id: r.event.id, undo: r.undo, warning: '' };
         } catch (e) { asActionError(e); }
       },
     }),
     undoMove: defineAction({
       input: z.union([
-        z.object({ kind: z.literal('series'), id: z.string(), days: z.number().int() }),
+        z.object({ kind: z.literal('series'), id: z.string(), days: z.number().int(), minutes: z.number().int().optional() }),
+        z.object({ kind: z.literal('date'), id: z.string(), key: z.string().max(20), previous: z.object({
+          start: z.string().max(20), end: z.string().max(20), roomIds: z.array(z.string()).max(50).optional(), note: z.string().max(500).default(''),
+          location: z.object({ name: z.string().max(300).default(''), address: z.string().max(500).default(''), url: z.string().max(2000).default('') }).partial().optional(),
+        }).nullable() }),
         z.object({ kind: z.literal('split'), id: z.string(), seriesId: z.string(), occurrence: z.string().max(20) }),
       ]),
       handler: async (undo, ctx) => {
-        await requireCan(ctx, 'content.edit');
+        const who = actorOf(await requireCan(ctx, 'content.edit'));
+        const repo = await getRepo(ctx.locals);
+        try { await undoMove(repo, who, undo as Parameters<typeof undoMove>[2], await publishHooks(ctx)); return { ok: true }; } catch (e) { asActionError(e); }
+      },
+    }),
+    // Event editor → Dates: move one date (new date, time, rooms and a public
+    // note), at once like cancelling it. `warning`: what else takes its rooms then.
+    moveDate: defineAction({
+      input: z.object({ id: z.string(), key: z.string().max(20), start: z.string().max(20), end: z.string().max(20).default(''),
+        roomIds: z.array(z.string()).max(50).optional(), note: z.string().max(500).default('') }),
+      handler: async ({ id, key, start, end, roomIds, note }, ctx) => {
+        const who = actorOf(await requireCan(ctx, 'content.edit'));
+        const repo = await getRepo(ctx.locals);
+        try {
+          const r = await moveOccurrence(repo, who, id, key, { start, end: end || undefined, roomIds, note }, await publishHooks(ctx));
+          return { id, warning: await clashWarning(repo, r.clashes) };
+        } catch (e) { asActionError(e); }
+      },
+    }),
+    // …and put a moved date back where the series has it
+    moveDateBack: defineAction({
+      input: z.object({ id: z.string(), key: z.string().max(20) }),
+      handler: async ({ id, key }, ctx) => {
+        const who = actorOf(await requireCan(ctx, 'content.edit'));
+        const repo = await getRepo(ctx.locals);
+        try {
+          const r = await moveOccurrenceBack(repo, who, id, key, await publishHooks(ctx));
+          return { id, warning: await clashWarning(repo, r.clashes) };
+        } catch (e) { asActionError(e); }
+      },
+    }),
+    // Event editor → Single dates: the next dates of a series (as saved), each
+    // moved, cancelled or as planned, and the rooms a date can move into
+    dates: defineAction({
+      input: z.object({ id: z.string(), limit: z.number().int().min(1).max(52).default(12) }),
+      handler: async ({ id, limit }, ctx) => {
+        await requireAdmin(ctx);
         const repo = await getRepo(ctx.locals);
-        try { await undoMove(repo, undo, await publishHooks(ctx)); return { ok: true }; } catch (e) { asActionError(e); }
+        const [e, settings, resources] = await Promise.all([repo.getEvent(id), repo.getSettings(), bookingsEnabled() ? repo.listResources() : Promise.resolve([])]);
+        if (!e) throw new ActionError({ code: 'NOT_FOUND', message: 'Event not found.' });
+        return { allDay: e.allDay, roomIds: e.roomHold.resourceIds, dates: upcomingDates(e, settings, limit), rooms: resources.map((r) => ({ id: r.id, name: r.name })) };
       },
     }),
     // Schedule: cancel (or restore) one date of a repeating event, at once

package/src/components/EventPage.astro

@@ -35,6 +35,8 @@ interface Props {
 const { event: e, occurrence: o, settings, calendars, html, upcoming, origin, preview = false, rsvp = null } = Astro.props;
 // the whole event, or just this date of a repeating one
 const cancelled = e.cancelled || Boolean(o.cancelled);
+// a moved date may be at its own place
+const where = o.moved?.location ?? e.location;
 const image = eventImage(e, settings);
 const tz = eventTimeZone(e, settings);
 const locale = siteLocale(settings);
@@ -52,13 +54,13 @@ const repeats = describeRepeat(e.rrule, e.start, (ymd) => {
   return new Date(Date.UTC(y, m - 1, d)).toLocaleDateString(locale, { month: 'short', day: 'numeric', year: 'numeric', timeZone: 'UTC' });
 }, lang);
 const ctaHref = safeHref(e.cta.href);
-const mapHref = e.location.url
-  ? safeHref(e.location.url)
-  : e.location.address
-    ? `https://www.google.com/maps/search/?api=1&query=${encodeURIComponent([e.location.name, e.location.address].filter(Boolean).join(', '))}`
+const mapHref = where.url
+  ? safeHref(where.url)
+  : where.address
+    ? `https://www.google.com/maps/search/?api=1&query=${encodeURIComponent([where.name, where.address].filter(Boolean).join(', '))}`
     : '';
 // static map (made when the event was saved; see lib/maps/service.ts)
-const loc = e.location;
+const loc = where;
 const showMap = loc.showMap !== false && Boolean(loc.mapImage) && typeof loc.lat === 'number' && typeof loc.lng === 'number';
 const directions = showMap ? safeHref(directionsUrl(loc)) : '';
 const mapCredit = showMap ? mapAttribution(loc.mapImage) : '';
@@ -76,7 +78,7 @@ const I = {
   info: 'M12 21a9 9 0 1 0 0-18 9 9 0 0 0 0 18zM12 11v5M12 8h.01',
   video: 'M3 7h12v10H3zM15 10l6-3v10l-6-3',
 };
-const online = /zoom\.us|meet\.google|teams\.microsoft|webex|whereby|jit\.si/i.test(e.location.url);
+const online = /zoom\.us|meet\.google|teams\.microsoft|webex|whereby|jit\.si/i.test(where.url);
 // the RSVP block speaks the page's language too
 const w = rsvpStrings(lang);
 const going = rsvp ? aroundCount(rsvp.going, w.personGoing, w.peopleGoing) : ['', ''];
@@ -91,6 +93,9 @@ const deadline = typeof rsvp?.closesAt === 'number' ? deadlineParts(rsvp.closesA
 const closesLine = deadline && taking ? fill(w.closesOn, deadline) : '';
 const closedLine = deadline && !rsvp!.open && !cancelled && rsvp!.closesAt! <= Date.now() ? fill(w.closedOn, deadline) : '';
 const dateCancelled = fill(ew.dateCancelled, { date: f.date });
+// "Moved from Thu, Jan 10 · 6:00 PM." (all-day: the date)
+const movedFrom = o.moved ? formatOccurrence({ start: o.moved.from.start, end: o.moved.from.end, allDay: o.allDay, days: o.days }, tz, locale) : null;
+const dateMoved = movedFrom ? fill(ew.dateMoved, { from: o.allDay ? movedFrom.date : movedFrom.range }) : '';
 const showing = fill(ew.showing, { date: f.date });
 const moreCards = upcoming.map((u) => eventCardHtml(u, settings, { showImage: true, href: here(eventUrl(u.event.slug)) })).join('');
 ---
@@ -113,6 +118,7 @@ const moreCards = upcoming.map((u) => eventCardHtml(u, settings, { showImage: tr
       <h1 class="pc-ev-title">{e.title}</h1>
       {e.cancelled && <p class="pc-ev-cancelled"><b>{ew.eventCancelled}</b> {ew.eventCancelledNote}</p>}
       {!e.cancelled && cancelled && <p class="pc-ev-cancelled"><b>{dateCancelled}</b> {ew.dateCancelledNote}</p>}
+      {!cancelled && dateMoved && <p class="pc-ev-moved"><b>{dateMoved}</b> {o.moved!.note || ew.dateMovedNote}</p>}
       {e.excerpt && <p class="pc-ev-lede">{e.excerpt}</p>}
       <div class="pc-ev-body post-content" set:html={html} />
     </div>
@@ -125,15 +131,15 @@ const moreCards = upcoming.map((u) => eventCardHtml(u, settings, { showImage: tr
           <span>{f.time}</span>
         </div>
       </div>
-      {(e.location.name || e.location.address || e.location.url) && (
+      {(where.name || where.address || where.url) && (
         <div class="pc-ev-fact">
-          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d={online && !e.location.address ? I.video : I.pin} /></svg>
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d={online && !where.address ? I.video : I.pin} /></svg>
           <div>
-            {e.location.name && <b>{e.location.name}</b>}
-            {(e.location.address || mapHref) && (
+            {where.name && <b>{where.name}</b>}
+            {(where.address || mapHref) && (
               <span>
-                {e.location.address}
-                {mapHref && <>{e.location.address && ' · '}<a href={mapHref} target="_blank" rel="noopener">{online ? ew.joinOnline : ew.map}</a></>}
+                {where.address}
+                {mapHref && <>{where.address && ' · '}<a href={mapHref} target="_blank" rel="noopener">{online ? ew.joinOnline : ew.map}</a></>}
               </span>
             )}
           </div>