@acms-subir/core 0.3.44 → 0.3.46

package/src/pages/api/calendar/docs.ts

@@ -59,6 +59,8 @@ Add endpoints in Team → API & webhooks. Events: event.published, event.updated
 Each POST has headers X-Acms-Event, X-Acms-Delivery, X-Acms-Timestamp and
 X-Acms-Signature: sha256=<hex HMAC-SHA256(secret, "<timestamp>.<raw body>")>.
 Body: { "id", "type", "createdAt", "data": { ... } }. Failed deliveries retry after 1, 10 and 60 minutes.
+event.* fire however an event changes: the editor, Schedule, this API, agent tools, scheduled
+publishing, a saved place's new address and environment sync. Restores send site.restored instead.
 
 ## MCP / agent tools
 

package/src/pages/api/calendar/events/[id].ts

@@ -7,7 +7,7 @@ import { CALENDAR } from '../../../../lib/calendar/config';
 import { eventIsPublic } from '../../../../lib/calendar/events';
 import { eventToJson } from '../../../../lib/calendar/api';
 import { runAgentTool } from '../../../../lib/agent';
-import { eventDeleted } from '../../../../lib/calendar/hooks';
+import { flushEventChanges } from '../../../../lib/calendar/hooks';
 import { mergeEventDraft } from '../../../../lib/drafts';
 import { waitUntilFrom } from '../../../../lib/webhooks';
 import { fail, preflight, withCors } from '../../../../lib/calendar/http';
@@ -27,12 +27,12 @@ export const GET: APIRoute = async ({ request, locals, url, params }) => {
   try {
     if (!CALENDAR.enabled) throw new ApiError(404, 'The calendar module is disabled.');
     const repo = await getRepo(locals);
-    const [e, settings, calendars, who] = await Promise.all([find(repo, params.id!), repo.getSettings(), repo.listCalendars(), authenticate(request, repo)]);
+    const [e, settings, calendars, who, rooms] = await Promise.all([find(repo, params.id!), repo.getSettings(), repo.listCalendars(), authenticate(request, repo), repo.listResources()]);
     const map = new Map(calendars.map((c) => [c.id, c]));
     const full = who ? hasScope(who, 'events:read') : false;
     if (!e || (!full && !eventIsPublic(e, map))) throw new ApiError(404, 'Event not found.');
     const view = full ? mergeEventDraft(e) : e;
-    return withCors(json({ event: { ...eventToJson(view, siteOrigin(settings, url), map, settings.timezone, { includePrivate: full }), ...(full ? { hasPendingDraft: Boolean(e.draft), bodyHtml: view.bodyHtml } : {}) } }));
+    return withCors(json({ event: { ...eventToJson(view, siteOrigin(settings, url), map, settings.timezone, { includePrivate: full, resources: new Map(rooms.map((r) => [r.id, r])) }), ...(full ? { hasPendingDraft: Boolean(e.draft), bodyHtml: view.bodyHtml } : {}) } }));
   } catch (err) { return fail(err); }
 };
 
@@ -50,14 +50,14 @@ export const PATCH: APIRoute = async ({ request, locals, url, params }) => {
   } catch (err) { return fail(err); }
 };
 
-export const DELETE: APIRoute = async ({ request, locals, params }) => {
+export const DELETE: APIRoute = async ({ request, locals, url, params }) => {
   try {
     const repo = await getRepo(locals);
     await requireScope(request, repo, 'events:write');
     const e = await find(repo, params.id!);
     if (!e) throw new ApiError(404, 'Event not found.');
     await repo.deleteEvent(e.id);
-    await eventDeleted(repo, e, { waitUntil: waitUntilFrom(locals) });
+    await flushEventChanges(repo, { origin: url.origin, waitUntil: waitUntilFrom(locals) });
     return withCors(json({ deleted: e.id }));
   } catch (err) { return fail(err); }
 };

package/src/pages/api/calendar/events/index.ts

@@ -5,7 +5,7 @@ import { authenticate, hasScope } from '../../../../lib/api-keys';
 import { siteOrigin } from '../../../../lib/seo';
 import { CALENDAR } from '../../../../lib/calendar/config';
 import { eventIsListed, eventIsPublic, expandEvents, parseWall } from '../../../../lib/calendar/events';
-import { eventToJson } from '../../../../lib/calendar/api';
+import { eventToJson, roomsToJson } from '../../../../lib/calendar/api';
 import { zonedToUtc } from '../../../../lib/calendar/ics';
 import { isoWithOffset } from '../../../../lib/calendar/seo';
 import { eventTimeZone } from '../../../../lib/calendar/events';
@@ -43,9 +43,10 @@ export const GET: APIRoute = async ({ request, locals, url }) => {
     const principal = await authenticate(request, repo);
     if (request.headers.get('authorization') && !principal) throw new ApiError(401, 'Invalid API key.');
     const full = principal ? hasScope(principal, 'events:read') : false;
-    const [settings, calendars, published] = await Promise.all([repo.getSettings(), repo.listCalendars(), repo.listPublishedEvents()]);
+    const [settings, calendars, published, rooms] = await Promise.all([repo.getSettings(), repo.listCalendars(), repo.listPublishedEvents(), repo.listResources()]);
     const tz = settings.timezone || 'UTC';
     const map = new Map(calendars.map((c) => [c.id, c]));
+    const resources = new Map(rooms.map((r) => [r.id, r]));
     const origin = siteOrigin(settings, url);
 
     const slug = url.searchParams.get('calendar');
@@ -64,7 +65,7 @@ export const GET: APIRoute = async ({ request, locals, url }) => {
     }
 
     if (url.searchParams.get('expand') === '0') {
-      return withCors(json({ timezone: tz, events: events.map((e) => eventToJson(e, origin, map, settings.timezone, { includePrivate: full })) }));
+      return withCors(json({ timezone: tz, events: events.map((e) => eventToJson(e, origin, map, settings.timezone, { includePrivate: full, resources })) }));
     }
     const day = (param: string, fallback: number) => {
       const w = parseWall(url.searchParams.get(param) ?? '');
@@ -78,7 +79,7 @@ export const GET: APIRoute = async ({ request, locals, url }) => {
     const occ = expandEvents(events, settings, { displayTz: tz, now, windowStartMs: from, windowEndMs: to }).slice(0, limit);
     const cache = new Map<string, ReturnType<typeof eventToJson>>();
     const toJson = (id: string) => {
-      if (!cache.has(id)) cache.set(id, eventToJson(events.find((e) => e.id === id)!, origin, map, settings.timezone, { includePrivate: full }));
+      if (!cache.has(id)) cache.set(id, eventToJson(events.find((e) => e.id === id)!, origin, map, settings.timezone, { includePrivate: full, resources }));
       return cache.get(id)!;
     };
     return withCors(json({
@@ -93,6 +94,8 @@ export const GET: APIRoute = async ({ request, locals, url }) => {
           end: o.allDay ? isoWithOffset(o.end - 86_400_000, etz).slice(0, 10) : isoWithOffset(o.end, etz),
           allDay: o.allDay,
           cancelled: o.cancelled,
+          // that date's rooms
+          rooms: roomsToJson(o.roomIds, resources, full),
           event: toJson(o.event.id),
         };
       }),

package/src/pages/api/v1/rooms/free.ts

@@ -0,0 +1,7 @@
+import { roomFree } from '../../../../lib/mobile/calendar';
+import { privateRoute } from '../../../../lib/mobile/route';
+import { methodNotAllowed } from '../../../../lib/mobile/http';
+export { preflight as OPTIONS } from '../../../../lib/mobile/http';
+// never cached: a room taken a minute ago must not read as free
+export const GET = privateRoute(roomFree);
+export const ALL = () => methodNotAllowed('GET, OPTIONS');

package/src/pages/api/webhooks/docs.ts

@@ -24,6 +24,11 @@ Restoring design history only stages a draft; publishing it emits this event.
 media.created/updated/deleted: a media record is added, its alt text changes, or it is removed.
 site.restored: a content backup is restored; resync instead of expecting individual record events.
 announcement.published: an announcement goes up (acms({ announcements }); scheduled ones when their time comes).
+event.published/updated/unpublished/deleted: a calendar event goes public, changes, stops being
+public or is deleted, by any path: the editor, Schedule, list actions, agent tools, the REST API,
+scheduled publishing, a saved place's new address and environment sync. event.updated means
+something public changed (times, place, rooms, cancelled dates, text, translations); hosts,
+members' requests and staged edits do not emit it. A restore sends site.restored instead.
 Existing event.* and booking.* payloads are described at /api/calendar/docs.
 
 ## Payloads

package/src/server/index.ts

@@ -36,6 +36,7 @@ export interface ServerUser {
 
 export type { CalEvent, Occurrence };
 export type { EventRequestInput } from '../lib/calendar/requests';
+export type { EventClash, BusySlot, Hold } from '../lib/booking/holds';
 
 export interface ListEventsOptions {
   /** only published events (default: every event except archived ones) */
@@ -171,6 +172,42 @@ export async function restoreOccurrence(repo: Repo, eventId: string, occurrenceK
   return restore(internal(repo), eventId, occurrenceKey, { url: context.url, locals: context.locals });
 }
 
+// ---- rooms -----------------------------------------------------------------
+// Events hold rooms (CalEvent.roomHold) while they happen. These find where
+// two things want the same room. They don't check permissions, and their
+// results carry names: show them to staff only.
+
+/**
+ * Other events holding the same rooms as this one at overlapping times, setup
+ * and cleanup included, soonest first. Pass an event id, or a CalEvent with
+ * unsaved values (it's checked as if published). Looks `horizonDays` ahead
+ * (default 366) from `now`. Clashes are warnings: both events keep the room.
+ * Throws an Error with `status` 404 for an unknown event id.
+ */
+export async function eventRoomClashes(repo: Repo, event: string | CalEvent, opts: { horizonDays?: number; now?: Date | number } = {}): Promise<import('../lib/booking/holds').EventClash[]> {
+  const r = internal(repo);
+  const e = typeof event === 'string' ? await r.getEvent(event) : event;
+  if (!e) throw Object.assign(new Error('Event not found.'), { status: 404 });
+  const { eventClashes } = await import('../lib/booking/holds');
+  return (await eventClashes(r, await r.getSettings(), e, { horizonDays: opts.horizonDays, now: opts.now === undefined ? undefined : +opts.now })).clashes;
+}
+
+/**
+ * Everything that takes these rooms (Resource ids) in [from, to), soonest
+ * first: events holding them (setup and cleanup included), pending and
+ * confirmed bookings, staff blocks and the rooms' busy calendars. `ignore`
+ * leaves out one event, or one date of it by occurrence key, such as the date
+ * you're about to move. An empty list means they're all free.
+ */
+export async function roomBusy(repo: Repo, q: { roomIds: string[]; from: Date | number; to: Date | number; ignore?: { eventId: string; key?: string } }): Promise<import('../lib/booking/holds').BusySlot[]> {
+  const from = +q.from, to = +q.to;
+  if (!Number.isFinite(from) || !Number.isFinite(to) || to <= from) throw new RangeError('roomBusy needs a "to" after "from".');
+  if (to - from > MAX_WINDOW) throw new RangeError('roomBusy windows are at most 400 days.');
+  const r = internal(repo);
+  const { roomBusy: busy } = await import('../lib/booking/holds');
+  return busy(r, await r.getSettings(), { resourceIds: q.roomIds, from, to, ignore: q.ignore });
+}
+
 // ---- members' event requests ------------------------------------------
 // The rules behind the built-in "My events" pages (acms({ members })), for a
 // site that builds its own. Each takes the person acting (currentUser()) and

package/src/styles/admin.css

@@ -1392,6 +1392,9 @@ em.manual { color: var(--amber); }
 .res-grid > div > .card + .card, .res-side > .card + .card { margin-top: 16px; }
 .res-side { display: flex; flex-direction: column; gap: 0; }
 .res-side > .btn { margin-top: 14px; align-self: flex-start; }
+.res-color { display: flex; align-items: center; gap: 12px; margin-top: 4px; }
+.res-color input[type='color'] { width: 44px; height: 30px; padding: 2px; border: 1px solid var(--line); border-radius: var(--r-sm); background: var(--panel); cursor: pointer; }
+.res-color .check-row { margin: 0; }
 .card-pad { padding: 16px 18px; }
 .card-head { display: flex; justify-content: space-between; align-items: baseline; gap: 10px; margin-bottom: 12px; }
 .card-head b { font-size: 14.5px; }

package/src/styles/editor.css

@@ -1039,6 +1039,8 @@
 .rh-conflict > b { display: block; margin-bottom: 4px; }
 .rh-bk { display: flex; flex-direction: column; padding: 5px 0; border-top: 1px solid color-mix(in srgb, var(--amber) 25%, transparent); }
 .rh-bk small, .rh-more { color: var(--text-2); font-size: 11.5px; }
+.rh-clash .rh-bk a { color: inherit; font-weight: 600; }
+.rh-clash > .rh-more:last-child { display: block; margin-top: 6px; }
 .rh-acts { display: flex; gap: 6px; flex-wrap: wrap; margin-top: 8px; }
 .rh-acts.end { justify-content: flex-end; }
 .rh-cancel textarea, .rh-msg { width: 100%; margin-top: 8px; padding: 7px 9px; border: 1px solid var(--line-strong); border-radius: 8px; background: var(--bg); color: var(--text); font: inherit; font-size: 12.5px; resize: vertical; }