@acms-subir/core 0.3.21 → 0.3.22

package/src/pages/members/events/index.astro

@@ -0,0 +1,218 @@
+---
+import Layout from '../_Layout.astro';
+import { getRepo } from '../../../lib/repo';
+import { currentUser } from '../../../server';
+import { ApiError } from '../../../lib/api';
+import { readForm } from '../../../lib/forms/http';
+import { MEMBERS, memberEventsPath, hostedEvents, withdrawEventRequest, dismissEventRequest, setHostedOccurrence } from '../../../lib/calendar/requests';
+import { eventUrl } from '../../../lib/calendar/config';
+import { eventIsPublic, eventTimeZone, expandEvents, featuredOccurrence, formatOccurrence, type Occurrence } from '../../../lib/calendar/events';
+import { describeRepeat } from '../../../lib/calendar/rrule';
+import { requestLabel } from '../../../lib/calendar/member-form';
+import { mergeEventDraft } from '../../../lib/drafts';
+import { siteLocale } from '../../../lib/dates';
+import type { CalEvent } from '../../../lib/schema';
+import { failure, keepPrivate, notFound, redirectTo, signInRedirect } from '../_http';
+
+// "My events": the person's requests, the events they host (each upcoming
+// date with a Cancel / Restore control) and their past events. The rules
+// live in lib/calendar/requests.ts; this page only shows them and posts.
+// A site replaces it with its own file at the same path.
+if (!MEMBERS.enabled) return notFound();
+const user = await currentUser(Astro);
+if (!user) return signInRedirect(Astro.url);
+keepPrivate(Astro.response.headers);
+const repo = await getRepo(Astro.locals);
+const home = memberEventsPath();
+const hooks = { url: Astro.url, locals: Astro.locals };
+
+let error = '';
+if (Astro.request.method === 'POST') {
+  try {
+    const form = await readForm(Astro.request);
+    const op = String(form.get('op') ?? '');
+    const id = String(form.get('id') ?? '');
+    if (op === 'withdraw') {
+      await withdrawEventRequest(repo, user, id, hooks);
+      return redirectTo(`${home}?withdrawn=1`);
+    }
+    if (op === 'dismiss') {
+      await dismissEventRequest(repo, user, id);
+      return redirectTo(home);
+    }
+    if (op === 'cancel-date' || op === 'restore-date') {
+      await setHostedOccurrence(repo, user, id, String(form.get('key') ?? ''), op === 'cancel-date', hooks);
+      return redirectTo(`${home}?${op === 'cancel-date' ? 'cancelled' : 'restored'}=1`);
+    }
+    throw new ApiError(400, 'That action isn’t available here.');
+  } catch (err) {
+    const f = failure(err);
+    error = f.message;
+    Astro.response.status = f.status;
+  }
+}
+
+const FLASH: [string, string][] = [
+  ['sent', 'Thanks! Your request is with the team. You’ll hear back once they’ve looked at it.'],
+  ['updated', 'Your request is updated and waiting for approval.'],
+  ['changes', 'Your changes are with the team. The event stays as it is until they approve them.'],
+  ['withdrawn', 'Request withdrawn.'],
+  ['cancelled', 'That date is cancelled. The calendar shows it as cancelled.'],
+  ['restored', 'That date is back on.'],
+];
+const flash = error ? '' : FLASH.find(([k]) => Astro.url.searchParams.has(k))?.[1] ?? '';
+
+const DAY = 86_400_000;
+const now = Date.now();
+const [settings, calendars, mine] = await Promise.all([repo.getSettings(), repo.listCalendars(), hostedEvents(repo, user.id)]);
+const calById = new Map(calendars.map((c) => [c.id, c]));
+const siteTz = settings.timezone || 'UTC';
+const locale = siteLocale(settings);
+const canRequest = user.can('events.request');
+const isLive = (e: CalEvent) => e.status === 'published' || e.status === 'scheduled';
+
+const format = (opts: Intl.DateTimeFormatOptions, tz: string) => {
+  try { return new Intl.DateTimeFormat(locale, { ...opts, timeZone: tz }); }
+  catch { return new Intl.DateTimeFormat('en-US', { ...opts, timeZone: 'UTC' }); }
+};
+/** "Tue, Oct 21 · 7:00 PM – 9:00 PM", or "Tue, Oct 21 · All day" */
+const when = (o: Occurrence) => {
+  const tz = o.allDay ? siteTz : eventTimeZone(o.event, settings);
+  const f = formatOccurrence(o, tz, locale);
+  return o.allDay ? f.range : `${f.range} – ${format({ hour: 'numeric', minute: '2-digit' }, tz).format(o.end)}`;
+};
+const day = (ms: number) => format({ month: 'short', day: 'numeric' }, siteTz).format(ms);
+const meta = (...parts: string[]) => parts.filter(Boolean).join(' · ');
+
+// requests: waiting ones first, newest first; shown as they'd be once approved
+const requests = mine
+  .filter((e) => e.request)
+  .sort((a, b) => Number(b.request!.state === 'pending') - Number(a.request!.state === 'pending') || b.request!.at - a.request!.at)
+  .map((e) => {
+    // the host's own waiting changes, never staff's unpublished edits
+    const shown = e.request!.kind === 'changes' && e.request!.state === 'pending' ? mergeEventDraft(e) : e;
+    const o = featuredOccurrence(shown, settings, now);
+    return { e, r: e.request!, title: shown.title, line: meta(o ? when(o) : '', describeRepeat(shown.rrule, shown.start), shown.location.name) };
+  });
+
+// live events they host: the next 8 dates, or (all dates over) the last one
+const win = { displayTz: siteTz, now, windowStartMs: now, windowEndMs: now + 366 * DAY };
+const upcoming: { e: CalEvent; dates: Occurrence[] }[] = [];
+const past: { e: CalEvent; last: Occurrence | null }[] = [];
+for (const e of mine) {
+  if (!isLive(e) || !e.hostIds.includes(user.id)) continue;
+  const dates = expandEvents([e], settings, win).filter((o) => o.end > now).slice(0, 8);
+  if (!dates.length && e.startAt > now) {
+    const next = featuredOccurrence(e, settings, now);
+    if (next) dates.push(next);
+  }
+  if (dates.length) upcoming.push({ e, dates });
+  else past.push({ e, last: featuredOccurrence(e, settings, now) });
+}
+upcoming.sort((a, b) => a.dates[0].start - b.dates[0].start);
+past.sort((a, b) => (b.last?.start ?? b.e.startAt) - (a.last?.start ?? a.e.startAt));
+const pastShown = past.slice(0, 10);
+---
+
+<Layout title="My events" user={user}>
+  <div class="pc-mem-head">
+    <h1>My events</h1>
+    {canRequest && <a class="pc-mem-btn is-primary" href={`${home}/new`}>Request an event</a>}
+  </div>
+  {flash && <p class="pc-mem-flash" role="status">{flash}</p>}
+  {error && <p class="pc-bk-error" role="alert">{error}</p>}
+
+  {requests.length > 0 && (
+    <section aria-labelledby="pc-mem-requests">
+      <h2 id="pc-mem-requests">Requests</h2>
+      <ul class="pc-mem-list">
+        {requests.map(({ e, r, title, line }) => (
+          <li class="pc-mem-card">
+            <p class={`pc-mem-state is-${r.state}`}>{requestLabel(r)}</p>
+            <h3>{title}</h3>
+            {line && <p class="pc-mem-meta">{line}</p>}
+            <p class="pc-mem-meta">Sent {day(r.at)}</p>
+            {r.state === 'declined' && r.reply && <p class="pc-mem-reply"><strong>The team said:</strong> {r.reply}</p>}
+            <div class="pc-mem-actions">
+              {canRequest && <a class="pc-mem-btn is-small" href={`${home}/${e.id}`}>{r.kind === 'changes' && r.state === 'declined' ? 'Suggest changes again' : 'Edit'}</a>}
+              {r.kind === 'changes' && r.state === 'declined' ? (
+                <form method="post">
+                  <input type="hidden" name="op" value="dismiss" />
+                  <input type="hidden" name="id" value={e.id} />
+                  <button class="pc-mem-btn is-small" type="submit">Dismiss</button>
+                </form>
+              ) : canRequest && (
+                <form method="post" onsubmit={r.kind === 'new' ? "return confirm('Withdraw this request?')" : "return confirm('Withdraw these changes?')"}>
+                  <input type="hidden" name="op" value="withdraw" />
+                  <input type="hidden" name="id" value={e.id} />
+                  <button class="pc-mem-btn is-small is-danger" type="submit">Withdraw</button>
+                </form>
+              )}
+            </div>
+          </li>
+        ))}
+      </ul>
+    </section>
+  )}
+
+  <section aria-labelledby="pc-mem-upcoming">
+    <h2 id="pc-mem-upcoming">Upcoming</h2>
+    {upcoming.length === 0 ? (
+      <p class="pc-mem-empty">
+        You’re not hosting any upcoming events.
+        {canRequest && requests.length === 0 && <> <a href={`${home}/new`}>Request one</a> and the team will take a look.</>}
+      </p>
+    ) : (
+      <ul class="pc-mem-list">
+        {upcoming.map(({ e, dates }) => (
+          <li class="pc-mem-card">
+            {e.cancelled ? <p class="pc-mem-state is-declined">Cancelled</p>
+              : e.status === 'scheduled' && <p class="pc-mem-state is-pending">{e.scheduledAt ? `Goes live ${day(e.scheduledAt)}` : 'Scheduled'}</p>}
+            <h3>{e.title}</h3>
+            {meta(describeRepeat(e.rrule, e.start), e.location.name) && <p class="pc-mem-meta">{meta(describeRepeat(e.rrule, e.start), e.location.name)}</p>}
+            <ul class="pc-mem-dates">
+              {dates.map((o) => {
+                const off = e.cancelledDates.includes(o.key);
+                return (
+                  <li class={o.cancelled ? 'is-cancelled' : undefined}>
+                    <span>{o.cancelled ? <s>{when(o)}</s> : when(o)}{o.cancelled && <em>Cancelled</em>}</span>
+                    {e.rrule && !e.cancelled && o.start > now && (
+                      <form method="post" onsubmit={off ? undefined : "return confirm('Cancel this date? It shows as cancelled straight away.')"}>
+                        <input type="hidden" name="op" value={off ? 'restore-date' : 'cancel-date'} />
+                        <input type="hidden" name="id" value={e.id} />
+                        <input type="hidden" name="key" value={o.key} />
+                        <button class={`pc-mem-btn is-small${off ? '' : ' is-danger'}`} type="submit" aria-label={`${off ? 'Restore' : 'Cancel'} ${when(o)}`}>{off ? 'Restore' : 'Cancel'}</button>
+                      </form>
+                    )}
+                  </li>
+                );
+              })}
+            </ul>
+            <div class="pc-mem-actions">
+              {canRequest && <a class="pc-mem-btn is-small" href={`${home}/${e.id}`}>Suggest changes</a>}
+              {eventIsPublic(e, calById) && <a class="pc-mem-btn is-small" href={eventUrl(e.slug)}>View</a>}
+            </div>
+          </li>
+        ))}
+      </ul>
+    )}
+  </section>
+
+  {past.length > 0 && (
+    <section aria-label="Past events">
+      <details class="pc-mem-past">
+        <summary>Past events ({past.length})</summary>
+        <ul class="pc-mem-list">
+          {pastShown.map(({ e, last }) => (
+            <li class="pc-mem-card">
+              <h3>{e.title}</h3>
+              {last && <p class="pc-mem-meta">{when(last)}</p>}
+              {eventIsPublic(e, calById) && <div class="pc-mem-actions"><a class="pc-mem-btn is-small" href={eventUrl(e.slug)}>View</a></div>}
+            </li>
+          ))}
+        </ul>
+        {past.length > pastShown.length && <p class="pc-mem-hint">Showing the {pastShown.length} most recent.</p>}
+      </details>
+    </section>
+  )}
+</Layout>

package/src/pages/members/events/new.astro

@@ -0,0 +1,48 @@
+---
+import Layout from '../_Layout.astro';
+import EventForm from '../_EventForm.astro';
+import { getRepo } from '../../../lib/repo';
+import { currentUser } from '../../../server';
+import { readForm } from '../../../lib/forms/http';
+import { MEMBERS, memberEventsPath, submitEventRequest } from '../../../lib/calendar/requests';
+import { blankEventForm, eventRequestInput, memberEventFields, readEventForm } from '../../../lib/calendar/member-form';
+import { failure, keepPrivate, notFound, redirectTo, signInRedirect } from '../_http';
+
+// "Request an event": a draft the member hosts, waiting for the team's
+// approval (submitEventRequest checks who may ask and what they sent).
+if (!MEMBERS.enabled) return notFound();
+const user = await currentUser(Astro);
+if (!user) return signInRedirect(Astro.url);
+keepPrivate(Astro.response.headers);
+const repo = await getRepo(Astro.locals);
+const home = memberEventsPath();
+const fields = memberEventFields();
+const calendars = (await repo.listCalendars()).filter((c) => c.kind === 'native' && c.visibility === 'public');
+
+let values = blankEventForm(fields);
+let error = '';
+if (Astro.request.method === 'POST') {
+  try {
+    const form = await readForm(Astro.request);
+    values = readEventForm(form, fields);
+    await submitEventRequest(repo, user, eventRequestInput(values), { url: Astro.url, locals: Astro.locals });
+    return redirectTo(`${home}?sent=1`);
+  } catch (err) {
+    const f = failure(err);
+    error = f.message;
+    Astro.response.status = f.status;
+  }
+}
+const canRequest = user.can('events.request');
+---
+
+<Layout title="Request an event" user={user}>
+  <div>
+    <a class="pc-mem-back" href={home}>← My events</a>
+    <div class="pc-mem-head"><h1>Request an event</h1></div>
+    <p class="pc-mem-lede">Tell the team what you’d like to host. It goes on the calendar once they approve it.</p>
+  </div>
+  {canRequest
+    ? <EventForm values={values} calendars={calendars} fields={fields} op="submit" submitLabel="Submit for approval" error={error} />
+    : <p class="pc-bk-error" role="alert">Your role doesn’t include “Request events”. Ask the site’s team if you need it.</p>}
+</Layout>

package/src/pages/members/index.ts

@@ -0,0 +1,6 @@
+import type { APIRoute } from 'astro';
+import { MEMBERS, memberEventsPath } from '../../lib/calendar/requests';
+import { notFound, redirectTo } from './_http';
+
+// acms({ members }).base: "My events" is the only member page so far.
+export const GET: APIRoute = () => (MEMBERS.enabled ? redirectTo(memberEventsPath(), 302) : notFound());

package/src/server/index.ts

@@ -2,11 +2,12 @@
 // 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.
+// contract (see docs/server.md, `acms docs server`). The event and date
+// functions don't check permissions (callers decide who may change what); the
+// event-request functions take the person acting and check them themselves.
 import type { AstroCookies } from 'astro';
 import type { ContentRepository } from '../lib/repo/types';
-import type { CalEvent, Role } from '../lib/schema';
+import type { CalEvent, CoreRole } from '../lib/schema';
 import type { Occurrence } from '../lib/calendar/events';
 
 /** A handle to the site's content store. Pass it to the functions below. */
@@ -14,23 +15,35 @@ export interface Repo {
   readonly __acmsRepo: true;
 }
 
+/** A core role, or a key from the site's acms({ roles }) (e.g. 'host'). */
+export type Role = CoreRole | (string & {});
+
 /** 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 */
+  /** whether they may use the admin: core roles, and site roles with `admin: true` */
+  staff: boolean;
+  /**
+   * whether their role grants a permission key: a core one ('content.edit') or
+   * one from acms({ permissions }) ('classes.manageAll'). Unknown keys are
+   * false; a role without admin access only ever holds site permissions.
+   */
   can(permission: string): boolean;
 }
 
 export type { CalEvent, Occurrence };
+export type { EventRequestInput } from '../lib/calendar/requests';
 
 export interface ListEventsOptions {
   /** only published events (default: every event except archived ones) */
   publishedOnly?: boolean;
   /** only events in this calendar (id or slug) */
   calendar?: string;
+  /** only events this Team member hosts (CalEvent.hostIds) */
+  hostedBy?: string;
 }
 
 export interface OccurrenceWindow {
@@ -57,27 +70,31 @@ export async function getRepo(locals: unknown): Promise<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.
+ * The person signed in on this request, on any page (public pages included),
+ * or null: staff, and people in the site's own roles (acms({ roles })) who
+ * can't use the admin. 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'),
+  const [{ getRequestAuth }, { grantsFor }, { allows }, { isStaffRole }, { OWNER_ENV }, { getRepo: load }] = await Promise.all([
+    import('../lib/auth/request'), import('../lib/permissions/access'), import('../lib/permissions/catalog'), import('../lib/roles'), 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 auth = await getRequestAuth(context.request, context.cookies, context.locals);
+  if (!auth.person) return null;
   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);
+  const user = auth.person.id === OWNER_ENV ? null : await repo.getUser(auth.person.id);
+  if (auth.person.id !== OWNER_ENV && !user) return null;
+  const role = user?.role ?? 'owner';
+  const grants = await grantsFor(repo, context.request);
   return {
-    id: access.userId,
+    id: auth.person.id,
     email: user?.email ?? '',
-    name: access.name,
-    role: access.role,
-    can: (permission: string) => isPermission(permission) && access.can(permission),
+    name: user?.name ?? 'Owner',
+    role,
+    staff: isStaffRole(role),
+    can: (permission: string) => allows(grants, role, permission),
   };
 }
 
@@ -90,6 +107,7 @@ export async function listEvents(repo: Repo, opts: ListEventsOptions = {}): Prom
     if (!cal) return [];
     events = events.filter((e) => e.calendarIds.includes(cal.id));
   }
+  if (opts.hostedBy) events = events.filter((e) => e.hostIds.includes(opts.hostedBy!));
   return events;
 }
 
@@ -139,3 +157,63 @@ export async function restoreOccurrence(repo: Repo, eventId: string, occurrenceK
   const { restoreOccurrence: restore } = await import('../lib/calendar/schedule');
   return restore(internal(repo), eventId, occurrenceKey, { url: context.url, locals: context.locals });
 }
+
+// ---- 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
+// checks them itself: members need "Request events" and only touch events
+// they host; approving and declining need "Publish content". Errors carry a
+// `status` (400, 401, 403, 404, 409, 429) and a message safe to show people.
+
+type Who = Pick<ServerUser, 'id' | 'can'> | null;
+const requests = () => import('../lib/calendar/requests');
+
+/** The events this person hosts plus their own requests (pending or declined), soonest first. */
+export async function listMyEvents(repo: Repo, who: Who): Promise<CalEvent[]> {
+  if (!who) return [];
+  return (await requests()).hostedEvents(internal(repo), who.id);
+}
+
+/** Requests waiting for staff (new events and suggested changes), oldest first; for people who can approve them ("Publish content"). */
+export async function listEventRequests(repo: Repo, who: Who): Promise<CalEvent[]> {
+  if (!who) throw Object.assign(new Error('Sign in to continue.'), { status: 401 });
+  if (!who.can('content.publish')) throw Object.assign(new Error('Your role doesn’t include “Publish content”, which approving requests needs.'), { status: 403 });
+  return (await requests()).pendingRequests(internal(repo));
+}
+
+/** Ask for a new event: a draft the person hosts, waiting for approval. Staff are emailed. */
+export async function submitEventRequest(repo: Repo, who: Who, input: import('../lib/calendar/requests').EventRequestInput, context: WriteContext): Promise<CalEvent> {
+  return (await requests()).submitEventRequest(internal(repo), who, input, context);
+}
+
+/**
+ * Edit a request, or suggest changes to a live event the person hosts. A live
+ * event keeps showing what it shows until staff approve the changes.
+ */
+export async function updateEventRequest(repo: Repo, who: Who, eventId: string, input: import('../lib/calendar/requests').EventRequestInput, context: WriteContext): Promise<CalEvent> {
+  return (await requests()).updateEventRequest(internal(repo), who, eventId, input, context);
+}
+
+/** Take a request back: a new event that never went live is deleted; suggested changes are dropped. */
+export async function withdrawEventRequest(repo: Repo, who: Who, eventId: string, context: WriteContext): Promise<{ deleted: boolean }> {
+  return (await requests()).withdrawEventRequest(internal(repo), who, eventId, context);
+}
+
+/**
+ * Staff: approve (a new event is published; suggested changes go live). The
+ * requester is emailed. Pass `seen`, the `request.at` of the version you showed,
+ * and it answers 409 if the member changed the request since.
+ */
+export async function approveEventRequest(repo: Repo, who: Who, eventId: string, context: WriteContext, seen?: number): Promise<CalEvent> {
+  return (await requests()).approveEventRequest(internal(repo), who, eventId, context, seen);
+}
+
+/** Staff: decline with a note for the requester (emailed). A new request stays a draft they can edit and resend. */
+export async function declineEventRequest(repo: Repo, who: Who, eventId: string, reply: string, context: WriteContext, seen?: number): Promise<CalEvent> {
+  return (await requests()).declineEventRequest(internal(repo), who, eventId, reply, context, seen);
+}
+
+/** A host cancels (or restores) one date of an event they host, at once. Same rules as cancelOccurrence. */
+export async function setHostedOccurrence(repo: Repo, who: Who, eventId: string, occurrenceKey: string, cancelled: boolean, context: WriteContext): Promise<CalEvent> {
+  return (await requests()).setHostedOccurrence(internal(repo), who, eventId, occurrenceKey, cancelled, context);
+}

package/src/virtual.d.ts

@@ -19,6 +19,10 @@ declare module 'virtual:acms-config' {
     // resolved by integration.mjs; '' = pick from the environment (lib/maps/config.ts)
     maps?: { provider: '' | 'geoapify' | 'google' | 'mapbox' | 'locationiq' | 'stadia' | 'photon' | 'nominatim' | 'pelias' };
     legal?: { enabled: boolean; operatorName: string; contactEmail: string; updatedAt: string };
+    // resolved by integration.mjs (lib/roles.ts and lib/permissions/catalog.ts read them)
+    roles?: { key: string; label: string; summary: string; admin: boolean; home: string }[];
+    permissions?: { key: string; label: string; description: string; defaults: string[]; sensitive: boolean }[];
+    members?: { enabled: boolean; base: string; notify: string[] };
     // resolved by integration.mjs (lib/calendar/config.ts documents the shape)
     calendar?: {
       enabled: boolean;