@acms-subir/core 0.3.19 → 0.3.21

package/src/pages/events/[slug].astro

@@ -16,7 +16,7 @@ import { validateRequestSession } from '../../lib/auth/request';
 import { effectiveSettings } from '../../lib/designPreview';
 import { resolveDesign } from '../../lib/theme';
 import { siteOrigin } from '../../lib/seo';
-import { CALENDAR, eventUrl } from '../../lib/calendar/config';
+import { CALENDAR, eventUrl, withoutPrivateFields } from '../../lib/calendar/config';
 import { eventIsPublic, featuredOccurrence } from '../../lib/calendar/events';
 import { eventJsonLd } from '../../lib/calendar/seo';
 import { upcomingEvents } from '../../lib/calendar/cards';
@@ -31,7 +31,8 @@ if (!CALENDAR.enabled) return new Response(null, { status: 404, statusText: 'Not
 const repo = await getRepo(Astro.locals);
 const locale = requestLocale(Astro.url, Astro.locals);
 const rawEvent = await repo.getEventBySlug(Astro.params.slug ?? '');
-const event = rawEvent ? localizeDoc(rawEvent, locale) : null;
+// private custom fields never reach the page or a theme's event template
+const event = rawEvent ? withoutPrivateFields(localizeDoc(rawEvent, locale)) : null;
 const [rawSettings, allCalendars] = await Promise.all([repo.getSettings(), repo.listCalendars()]);
 const calMap = new Map(allCalendars.map((c) => [c.id, c]));
 const isAdmin = (await validateRequestSession(Astro.request, Astro.cookies, Astro.locals));
@@ -68,7 +69,7 @@ if (Astro.request.method === 'POST' && event.rsvp.enabled) {
 const formHtml = hiddenFields(await formVersion(definition), requestId) + `<input type="hidden" name="occurrence" value="${occurrence.start}">`;
 const taken = event.rsvp.enabled ? await seatsTaken(repo, event.id, occurrence.start) : 0;
 const rsvp = event.rsvp.enabled
-  ? { going: taken, left: event.rsvp.capacity ? Math.max(0, event.rsvp.capacity - taken) : null, maxSeats: event.rsvp.maxSeats, error: rsvpError, formHtml, fieldsHtml: renderFields(definition, formValues, 'event-registration'), values: coreValues, open: occurrence.end > now && !event.cancelled }
+  ? { going: taken, left: event.rsvp.capacity ? Math.max(0, event.rsvp.capacity - taken) : null, maxSeats: event.rsvp.maxSeats, error: rsvpError, formHtml, fieldsHtml: renderFields(definition, formValues, 'event-registration'), values: coreValues, open: occurrence.end > now && !occurrence.cancelled }
   : null;
 const calendars = event.calendarIds.map((id) => calMap.get(id)).filter((c): c is NonNullable<typeof c> => Boolean(c) && c!.visibility !== 'private');
 const html = highlightCodeHtml(await expandDynamicBlocks(event.bodyHtml, repo));

package/src/server/index.ts

@@ -0,0 +1,141 @@
+// @acms-subir/core/server — the small, stable API site code (Astro pages,
+// endpoints and actions in the site's own src/) uses to read events, find
+// the signed-in person and cancel single dates. It wraps the internals so
+// they can change without breaking sites; everything here is a public
+// contract (see docs/server.md, `acms docs server`). Nothing in this module
+// checks permissions on writes: callers decide who may change what.
+import type { AstroCookies } from 'astro';
+import type { ContentRepository } from '../lib/repo/types';
+import type { CalEvent, Role } from '../lib/schema';
+import type { Occurrence } from '../lib/calendar/events';
+
+/** A handle to the site's content store. Pass it to the functions below. */
+export interface Repo {
+  readonly __acmsRepo: true;
+}
+
+/** The signed-in person (null when signed out or removed). */
+export interface ServerUser {
+  id: string;
+  email: string;
+  name: string;
+  role: Role;
+  /** whether their role grants a permission key (e.g. 'content.edit'); unknown keys are false */
+  can(permission: string): boolean;
+}
+
+export type { CalEvent, Occurrence };
+
+export interface ListEventsOptions {
+  /** only published events (default: every event except archived ones) */
+  publishedOnly?: boolean;
+  /** only events in this calendar (id or slug) */
+  calendar?: string;
+}
+
+export interface OccurrenceWindow {
+  /** one event's occurrences; omit for every event (archived ones excluded) */
+  eventId?: string;
+  /** window start and end, as a Date or Unix milliseconds; at most 400 days */
+  from: Date | number;
+  to: Date | number;
+}
+
+/** Where a write came from: used for webhook URLs and background work. */
+export interface WriteContext {
+  url: URL;
+  locals: unknown;
+}
+
+const internal = (repo: Repo) => repo as unknown as ContentRepository;
+const MAX_WINDOW = 400 * 86_400_000;
+
+/** The site's repository for this request (`Astro.locals` or an endpoint's `locals`). */
+export async function getRepo(locals: unknown): Promise<Repo> {
+  const { getRepo: load } = await import('../lib/repo');
+  return (await load(locals)) as unknown as Repo;
+}
+
+/**
+ * The person signed in to the admin on this request, on any page (public
+ * pages included), or null. With Clerk sign-in, a signed-in browser carries
+ * the `__session` cookie and is resolved on every page except /media,
+ * /embed and /api/v1.
+ */
+export async function currentUser(context: { request: Request; cookies: AstroCookies | { get(name: string): { value: string } | undefined }; locals: unknown }): Promise<ServerUser | null> {
+  const [{ getRequestAuth }, { accessFor }, { isPermission }, { OWNER_ENV }, { getRepo: load }] = await Promise.all([
+    import('../lib/auth/request'), import('../lib/permissions/access'), import('../lib/permissions/catalog'), import('../lib/auth'), import('../lib/repo'),
+  ]);
+  // with locals first, so Clerk reads this deployment's keys (cached per request)
+  await getRequestAuth(context.request, context.cookies, context.locals);
+  const repo = await load(context.locals);
+  const access = await accessFor(context.request, context.cookies, repo);
+  if (!access) return null;
+  const user = access.userId === OWNER_ENV ? null : await repo.getUser(access.userId);
+  return {
+    id: access.userId,
+    email: user?.email ?? '',
+    name: access.name,
+    role: access.role,
+    can: (permission: string) => isPermission(permission) && access.can(permission),
+  };
+}
+
+/** Events by first start date (earliest first), with their live values (staged edits are not merged in). */
+export async function listEvents(repo: Repo, opts: ListEventsOptions = {}): Promise<CalEvent[]> {
+  const r = internal(repo);
+  let events = opts.publishedOnly ? await r.listPublishedEvents() : (await r.listEvents()).filter((e) => e.status !== 'archived');
+  if (opts.calendar) {
+    const cal = (await r.getCalendar(opts.calendar)) ?? (await r.getCalendarBySlug(opts.calendar));
+    if (!cal) return [];
+    events = events.filter((e) => e.calendarIds.includes(cal.id));
+  }
+  return events;
+}
+
+/** One event by id (null when it doesn't exist). */
+export async function getEvent(repo: Repo, id: string): Promise<CalEvent | null> {
+  return (await internal(repo).getEvent(id)) ?? null;
+}
+
+/**
+ * Every occurrence in [from, to), soonest first. Each carries its `key`
+ * (the occurrence key cancelOccurrence takes) and `cancelled` (the whole
+ * event, or just that date). Drafts are included: check `o.event.status`.
+ */
+export async function listOccurrences(repo: Repo, window: OccurrenceWindow): Promise<Occurrence[]> {
+  const from = +window.from, to = +window.to;
+  if (!Number.isFinite(from) || !Number.isFinite(to) || to <= from) throw new RangeError('listOccurrences needs a "to" after "from".');
+  if (to - from > MAX_WINDOW) throw new RangeError('listOccurrences windows are at most 400 days.');
+  const r = internal(repo);
+  const [{ expandEvents }, settings] = await Promise.all([import('../lib/calendar/events'), r.getSettings()]);
+  let events: CalEvent[];
+  if (window.eventId) {
+    const e = await r.getEvent(window.eventId);
+    events = e ? [e] : [];
+  } else {
+    events = (await r.listEvents()).filter((e) => e.status !== 'archived');
+  }
+  return expandEvents(events, settings, { displayTz: settings.timezone || 'UTC', now: Date.now(), windowStartMs: from, windowEndMs: to });
+}
+
+/**
+ * Cancel one date of a repeating event, at once, even on a published event:
+ * it stays listed struck through as "Cancelled", its room holds are freed,
+ * feeds and the app see it cancelled, and the event.updated webhook fires.
+ * Idempotent. Throws an Error with `status` 404 for an unknown event, or 400
+ * for an event that doesn't repeat, a key that isn't one of its dates, or a
+ * date that has started or passed; the message is safe to show people.
+ *
+ * Does NOT check permissions: check the caller's access first.
+ */
+export async function cancelOccurrence(repo: Repo, eventId: string, occurrenceKey: string, context: WriteContext): Promise<CalEvent> {
+  const { cancelOccurrence: cancel } = await import('../lib/calendar/schedule');
+  return cancel(internal(repo), eventId, occurrenceKey, { url: context.url, locals: context.locals });
+}
+
+/** Undo cancelOccurrence for one date. Same rules; idempotent; no permission checks. */
+export async function restoreOccurrence(repo: Repo, eventId: string, occurrenceKey: string, context: WriteContext): Promise<CalEvent> {
+  const { restoreOccurrence: restore } = await import('../lib/calendar/schedule');
+  return restore(internal(repo), eventId, occurrenceKey, { url: context.url, locals: context.locals });
+}

package/src/theme-sdk/calendar.ts

@@ -22,8 +22,12 @@ export interface UpcomingEventsOptions {
   horizonDays?: number;
 }
 
-/** Occurrence start/end are Unix milliseconds; event retains its authored fields. */
-export type UpcomingEvent = Pick<Occurrence, 'event' | 'start' | 'end' | 'allDay' | 'days'>;
+/**
+ * Occurrence start/end are Unix milliseconds; event retains its authored
+ * fields except private custom fields. `cancelled` is true when the whole
+ * event or just this date is cancelled.
+ */
+export type UpcomingEvent = Pick<Occurrence, 'event' | 'start' | 'end' | 'allDay' | 'days' | 'cancelled'>;
 
 /** Server-side helper for Astro templates and endpoints. No repository access needed. */
 export async function upcomingEvents(

package/src/virtual.d.ts

@@ -29,7 +29,7 @@ declare module 'virtual:acms-config' {
       bookBase: string;
       resourceKinds: string[];
       defaultView: 'month' | 'week' | 'list';
-      eventFields: { key: string; label: string; type: 'text' | 'textarea' | 'number' | 'url' | 'select'; options: string[] }[];
+      eventFields: { key: string; label: string; type: 'text' | 'textarea' | 'number' | 'url' | 'select'; options: string[]; private: boolean }[];
     };
   };
 }