@acms-subir/core 0.2.0 → 0.3.1

package/src/lib/mobile/bookings.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import type { ContentRepository } from '../repo/types';
+import type { Booking } from '../schema';
+import { ApiError, readJson } from '../api';
+import { sha256Hex } from '../api-keys';
+import { siteOrigin } from '../seo';
+import { eventIsPublic, expandEvents } from '../calendar/events';
+import { createResourceBooking, createRsvp, bookingJson } from '../booking/service';
+import { waitUntilFrom } from '../webhooks';
+import { requireCalendar } from './calendar';
+
+const common = {
+  start: z.string().datetime({ offset: true }),
+  name: z.string().trim().min(1).max(120), email: z.string().trim().email().max(200).transform(v => v.toLowerCase()),
+  phone: z.string().trim().max(40).default(''),
+};
+export const bookingInput = z.union([
+  z.object({ ...common, resource: z.string().min(1).max(200), link: z.string().min(1).max(200),
+    minutes: z.number().int().min(1).max(44640).optional(), answers: z.record(z.string().max(2000)).default({}),
+  }).strict(),
+  z.object({ ...common, event: z.string().min(1).max(200), seats: z.number().int().min(1).max(1000).default(1) }).strict(),
+]);
+function canonical(value: unknown): string {
+  if (value && typeof value === 'object' && !Array.isArray(value)) return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k,v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(',')}}`;
+  return JSON.stringify(value);
+}
+const bookingData = (booking: Booking) => ({ booking: bookingJson(booking), manageToken: booking.manageToken });
+export async function submitBooking(repo: ContentRepository, request: Request, locals?: unknown) {
+  requireCalendar(true);
+  const key = request.headers.get('idempotency-key') ?? '';
+  // Treat the key as a secret receipt. Require a fresh UUID per user intent.
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(key)) throw new ApiError(400, 'Send a random UUID v4 in Idempotency-Key and reuse it only for retries.');
+  const body = bookingInput.parse(await readJson(request, 50000));
+  const idempotency = { keyHash: await sha256Hex(key.toLowerCase()), requestHash: await sha256Hex(canonical(body)) };
+  const replay = async () => {
+    const record = await repo.getBookingRequest(idempotency.keyHash);
+    if (!record) return null;
+    if (record.requestHash !== idempotency.requestHash) throw new ApiError(409, 'This Idempotency-Key was already used with different details.');
+    const booking = await repo.getBooking(record.bookingId);
+    if (!booking) throw new ApiError(410, 'The original booking was removed. This key cannot be reused.');
+    return { data: bookingData(booking), replayed: true };
+  };
+  const existing = await replay();
+  if (existing) return existing;
+  try {
+    const settings = await repo.getSettings();
+    const flow = { origin: siteOrigin(settings, new URL(request.url)), locals, waitUntil: waitUntilFrom(locals), idempotency };
+    const start = Date.parse(body.start);
+    let booking: Booking;
+    if ('event' in body) {
+      const event = await repo.getEventBySlug(body.event) ?? await repo.getEvent(body.event);
+      const calendars = new Map((await repo.listCalendars()).map(c => [c.id, c]));
+      if (!event || !eventIsPublic(event, calendars)) throw new ApiError(404, 'Event not found.');
+      if (body.seats > (event.rsvp.maxSeats || 1)) throw new ApiError(400, 'Too many seats for one RSVP.');
+      const occurrence = expandEvents([event], settings, { displayTz: settings.timezone || 'UTC', now: Date.now(), windowStartMs: start, windowEndMs: start + 1 }).find(o => o.start === start);
+      if (!occurrence) throw new ApiError(400, 'Start must match an event occurrence exactly.');
+      booking = await createRsvp(repo, { event, start, end: occurrence.end, seats: body.seats, booker: body, source: 'web' }, flow);
+    } else {
+      const resource = await repo.getResourceBySlug(body.resource);
+      const link = resource ? await repo.getBookingLinkBySlug(resource.id, body.link) : null;
+      if (!resource || !link) throw new ApiError(404, 'Resource or booking link not found.');
+      const minutes = body.minutes ?? (link.mode === 'day' ? 1440 : link.mode === 'range' ? link.lengths[0] ?? link.duration : link.duration);
+      booking = await createResourceBooking(repo, { resource, link, start, end: start + minutes * 60000, booker: body, source: 'web' }, flow);
+    }
+    return { data: bookingData(booking), replayed: false };
+  } catch (error) {
+    // Another request may have committed while this one checked availability,
+    // or delivery may have failed after commit. The ledger is authoritative.
+    const existing = await replay();
+    if (existing) return existing;
+    throw error;
+  }
+}

package/src/lib/mobile/calendar.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import type { ContentRepository } from '../repo/types';
+import { ApiError } from '../api';
+import { CALENDAR, bookingsEnabled, resourceUrl, bookingLinkUrl } from '../calendar/config';
+import { calendarToJson, eventToJson } from '../calendar/api';
+import { eventIsListed, eventIsPublic, expandEvents } from '../calendar/events';
+import { availabilityContext } from '../booking/service';
+import { addDaysYmd, describeLink, linkLengths, slotsForDay, ymd } from '../booking/availability';
+import { siteOrigin } from '../seo';
+import { safeUrl } from './content';
+import { pageQuery, isoDay, queryParams } from './http';
+
+export function requireCalendar(bookings = false) {
+  if (!CALENDAR.enabled || (bookings && !bookingsEnabled())) throw new ApiError(404, 'This feature is disabled.');
+}
+export async function listCalendars(repo: ContentRepository, url: URL) {
+  requireCalendar();
+  z.object({}).strict().parse(queryParams(url));
+  const origin = siteOrigin(await repo.getSettings(), url);
+  return { calendars: (await repo.listCalendars()).filter(c => c.visibility === 'public').map(c => calendarToJson(c, origin)) };
+}
+export async function listEvents(repo: ContentRepository, url: URL) {
+  requireCalendar();
+  const q = z.object({ ...pageQuery, from: isoDay.optional(), to: isoDay.optional(), calendar: z.string().min(1).max(200).optional(), q: z.string().max(100).optional() }).strict().parse(queryParams(url));
+  const from = Date.parse(q.from ?? new Date().toISOString().slice(0, 10));
+  const to = q.to ? Date.parse(q.to) : from + 30 * 86400000;
+  if (to <= from || to - from > 90 * 86400000) throw new ApiError(400, 'Use an event window of 1 to 90 days.');
+  const [settings, calendars, events] = await Promise.all([repo.getSettings(), repo.listCalendars(), repo.listPublishedEvents()]);
+  const all = new Map(calendars.map(c => [c.id, c]));
+  const cal = q.calendar ? calendars.find(c => c.slug === q.calendar && c.visibility !== 'private') : null;
+  if (q.calendar && !cal) throw new ApiError(404, 'Calendar not found.');
+  const publicCalendars = new Map(calendars.filter(c => c.visibility === 'public' || c.id === cal?.id).map(c => [c.id, c]));
+  const visible = events.filter(e => (cal ? e.calendarIds.includes(cal.id) && eventIsPublic(e, all) : eventIsListed(e, all))
+    && (!q.q || `${e.title} ${e.excerpt} ${e.location.name}`.toLowerCase().includes(q.q.toLowerCase())));
+  const occurrences = expandEvents(visible, settings, { displayTz: settings.timezone || 'UTC', now: Date.now(), windowStartMs: from, windowEndMs: to });
+  occurrences.sort((a, b) => a.start - b.start || (a.event.id < b.event.id ? -1 : a.event.id > b.event.id ? 1 : 0));
+  const start = (q.page - 1) * q.limit;
+  const origin = siteOrigin(settings, url);
+  return {
+    timezone: settings.timezone || 'UTC', from: new Date(from).toISOString(), to: new Date(to).toISOString(),
+    occurrences: occurrences.slice(start, start + q.limit).map(o => {
+      const event = eventToJson(o.event, origin, publicCalendars, settings.timezone);
+      // Only configured public event fields; no undeclared imported metadata.
+      event.fields = Object.fromEntries(CALENDAR.eventFields.filter(f => Object.hasOwn(o.event.fields, f.key)).map(f => [f.key, o.event.fields[f.key]]));
+      event.image = safeUrl(o.event.cover, origin);
+      event.cta = { ...event.cta, href: safeUrl(event.cta.href, origin, true) };
+      return { id: `${o.event.id}:${o.start}`, start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(), allDay: o.allDay, event };
+    }),
+    pagination: { page: q.page, limit: q.limit, nextPage: occurrences.length > start + q.limit ? q.page + 1 : null },
+  };
+}
+export async function listResources(repo: ContentRepository, url: URL) {
+  requireCalendar(true);
+  const q = z.object(pageQuery).strict().parse(queryParams(url));
+  const [settings, resources, links] = await Promise.all([repo.getSettings(), repo.listResources(), repo.listBookingLinks()]);
+  const origin = siteOrigin(settings, url), start = (q.page - 1) * q.limit;
+  const visible = resources.filter(r => r.visibility === 'public');
+  return { resources: visible.slice(start, start + q.limit).map(r => ({
+    id: r.id, slug: r.slug, name: r.name, kind: r.kind, description: r.description, capacity: r.capacity, amenities: r.amenities,
+    photo: safeUrl(r.photo, origin), timezone: r.timezone || settings.timezone || 'UTC', url: origin + resourceUrl(r.slug),
+    links: links.filter(l => l.resourceId === r.id && l.active && l.visibility === 'public').map(l => ({
+      id: l.id, slug: l.slug, name: l.name, description: l.description, mode: l.mode, lengths: linkLengths(l), rules: describeLink(l),
+      askPhone: l.askPhone, autoConfirm: l.autoConfirm, url: origin + bookingLinkUrl(r.slug, l.slug),
+      questions: l.questions.map(({ id, label, type, required, options }) => ({ id, label, type, required, options })),
+    })),
+  })), pagination: { page: q.page, limit: q.limit, nextPage: visible.length > start + q.limit ? q.page + 1 : null } };
+}
+export async function getAvailability(repo: ContentRepository, url: URL) {
+  requireCalendar(true);
+  const q = z.object({ resource: z.string().min(1).max(200), link: z.string().min(1).max(200), from: isoDay.optional(),
+    days: z.coerce.number().int().min(1).max(31).default(7), minutes: z.coerce.number().int().min(1).max(44640).optional(),
+  }).strict().parse(queryParams(url));
+  const resource = await repo.getResourceBySlug(q.resource);
+  const link = resource ? await repo.getBookingLinkBySlug(resource.id, q.link) : null;
+  if (!resource || !link || !link.active) throw new ApiError(404, 'Resource or booking link not found.');
+  const settings = await repo.getSettings();
+  const ctx = await availabilityContext(repo, resource, link, settings);
+  const timezone = resource.timezone || settings.timezone || 'UTC';
+  const from = q.from ?? ymd(Date.now(), timezone);
+  return { timezone, mode: link.mode, lengths: linkLengths(link), autoConfirm: link.autoConfirm,
+    days: Array.from({ length: q.days }, (_, i) => addDaysYmd(from, i)).map(date => ({ date,
+      slots: slotsForDay(ctx, date, q.minutes).map(s => ({ start: new Date(s.start).toISOString(), end: new Date(s.end).toISOString(), minutes: s.minutes })),
+    })),
+  };
+}

package/src/lib/mobile/content.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import sanitizeHtml from 'sanitize-html';
+import type { ContentRepository } from '../repo/types';
+import type { Page, Post } from '../schema';
+import { publicTags } from '../schema';
+import { CONTENT, collectionUrl } from '../content';
+import { I18N, localeHomeUrl } from '../i18n';
+import { siteOrigin } from '../seo';
+import { renderMarkdown } from '../markdown';
+import { blocksToHtml } from '../blocksToHtml';
+import { ApiError } from '../api';
+import { pageQuery, queryParams } from './http';
+
+export const contentQuery = z.object({
+  ...pageQuery, kind: z.enum(['post', 'page']).optional(),
+  collection: z.string().min(1).max(80).optional(), locale: z.string().min(1).max(35).optional(),
+}).strict();
+export function safeUrl(value: string, origin: string, link = false): string {
+  if (!value) return '';
+  try {
+    const url = new URL(value, origin);
+    return (['http:', 'https:', ...(link ? ['mailto:', 'tel:'] : [])].includes(url.protocol) && !url.username && !url.password) ? url.href : '';
+  } catch { return ''; }
+}
+export function mobileHtml(html: string, origin: string) {
+  return sanitizeHtml(html, {
+    allowedTags: [...sanitizeHtml.defaults.allowedTags, 'img'],
+    allowedAttributes: { a: ['href', 'title'], img: ['src', 'alt', 'title', 'width', 'height'], th: ['colspan', 'rowspan'], td: ['colspan', 'rowspan'] },
+    allowedSchemes: ['https', 'http', 'mailto', 'tel'],
+    allowedSchemesByTag: { img: ['https', 'http'] },
+    allowProtocolRelative: false,
+    transformTags: {
+      a: (_tag, attrs) => ({ tagName: 'a', attribs: { ...attrs, href: safeUrl(attrs.href ?? '', origin, true) } }),
+      img: (_tag, attrs) => ({ tagName: 'img', attribs: { ...attrs, src: safeUrl(attrs.src ?? '', origin) } }),
+    },
+  });
+}
+const iso = (n: number | null) => n === null ? null : new Date(n).toISOString();
+function dto(doc: Page | Post, kind: 'page' | 'post', origin: string, detail: boolean) {
+  const post = kind === 'post' ? doc as Post : null;
+  const page = kind === 'page' ? doc as Page : null;
+  const result = {
+    id: doc.id, kind, slug: doc.slug, title: doc.title,
+    collection: post?.collection ?? null,
+    locale: page?.locale || I18N.defaultLocale || null,
+    url: safeUrl(post ? collectionUrl(post.collection, post.slug) : page!.isHome ? localeHomeUrl(page!.locale) : `/${page!.slug}`, origin),
+    excerpt: post?.excerpt ?? page!.seoDesc,
+    tags: post ? publicTags(post.tags) : [],
+    image: post ? safeUrl(post.cover, origin) : '', imageAlt: post?.coverAlt ?? '',
+    publishedAt: post ? iso(post.publishedAt) : null,
+    createdAt: iso(doc.createdAt), updatedAt: iso(doc.updatedAt),
+  };
+  if (!detail) return result;
+  // An intentionally empty canonical editor body must not revive legacy text.
+  const html = doc.bodyJson ? doc.bodyHtml : doc.bodyHtml || (post ? renderMarkdown(post.body) : blocksToHtml(page!.blocks));
+  return { ...result, content: { format: 'sanitized-html' as const, html: mobileHtml(html, result.url), dynamicWidgets: 'website-only' as const } };
+}
+function visible(doc: Page | Post, kind: 'page' | 'post') {
+  return doc.status === 'published' && (kind === 'page' || Object.hasOwn(CONTENT.collections, (doc as Post).collection));
+}
+export async function listContent(repo: ContentRepository, url: URL) {
+  const q = contentQuery.parse(queryParams(url));
+  if (q.collection && !Object.hasOwn(CONTENT.collections, q.collection)) throw new ApiError(400, 'Unknown collection.');
+  if (q.collection && q.kind === 'page') throw new ApiError(400, 'Pages do not belong to post collections.');
+  if (q.locale && !I18N.locales.includes(q.locale)) throw new ApiError(400, 'Unknown locale.');
+  const origin = siteOrigin(await repo.getSettings(), url);
+  const rows = await repo.listPublicContent({ ...q, collections: Object.keys(CONTENT.collections), defaultLocale: I18N.defaultLocale });
+  const items = await Promise.all(rows.slice(0, q.limit).map(async (r) => {
+    const doc = r.kind === 'post' ? await repo.getPost(r.id) : await repo.getPage(r.id);
+    return doc && visible(doc, r.kind) ? dto(doc, r.kind, origin, false) : null;
+  }));
+  return { items: items.filter((x) => x !== null), pagination: { page: q.page, limit: q.limit, nextPage: rows.length > q.limit ? q.page + 1 : null } };
+}
+export async function getContent(repo: ContentRepository, url: URL, id: string) {
+  const q = z.object({ kind: z.enum(['post', 'page']).optional() }).strict().parse(queryParams(url));
+  // IDs are UUIDs, but restored databases may contain arbitrary legacy IDs.
+  if (!id || id.length > 200) throw new ApiError(404, 'Content not found.');
+  const post = q.kind === 'page' ? null : await repo.getPost(id);
+  const page = q.kind === 'post' ? null : await repo.getPage(id);
+  if (!q.kind && post && page) throw new ApiError(400, 'Specify kind for this content ID.');
+  const kind = post ? 'post' : 'page';
+  const doc = post ?? page;
+  if (!doc || !visible(doc, kind)) throw new ApiError(404, 'Content not found.');
+  return dto(doc, kind, siteOrigin(await repo.getSettings(), url), true);
+}

package/src/lib/mobile/http.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { ApiError } from '../api';
+import { BookingError } from '../booking/service';
+import { sha256Hex } from '../api-keys';
+import type { ContentRepository } from '../repo/types';
+
+const headers = {
+  'Access-Control-Allow-Origin': '*',
+  'Access-Control-Allow-Methods': 'GET, HEAD, POST, OPTIONS',
+  'Access-Control-Allow-Headers': 'Content-Type, Idempotency-Key, If-None-Match',
+  'Access-Control-Expose-Headers': 'ETag, Retry-After, Idempotency-Replayed',
+  'X-Content-Type-Options': 'nosniff',
+  'Cache-Control': 'no-store',
+};
+export const preflight = () => new Response(null, { status: 204, headers });
+export const response = (data: unknown, status = 200, extra: HeadersInit = {}) => {
+  const h = new Headers(headers);
+  new Headers(extra).forEach((value, key) => h.set(key, value));
+  return Response.json({ version: 1, data }, { status, headers: h });
+};
+export async function publicResponse(request: Request, data: unknown) {
+  const res = response(data);
+  const etag = `"${await sha256Hex(await res.clone().text())}"`;
+  res.headers.set('ETag', etag);
+  // Revalidate even fresh-looking content: unpublishing must take effect.
+  res.headers.set('Cache-Control', 'public, max-age=0, must-revalidate');
+  const match = request.headers.get('if-none-match')?.split(',').some((s) => s.trim().replace(/^W\//, '') === etag || s.trim() === '*');
+  return match ? new Response(null, { status: 304, headers: res.headers }) : res;
+}
+export function failure(error: unknown) {
+  const status = error instanceof ApiError || error instanceof BookingError ? error.status : error instanceof z.ZodError ? 400 : 500;
+  const codes: Record<number, string> = { 400: 'invalid_request', 404: 'not_found', 405: 'method_not_allowed', 409: 'conflict', 410: 'gone', 413: 'payload_too_large', 415: 'unsupported_media_type', 429: 'rate_limited' };
+  return Response.json({ version: 1, error: {
+    code: codes[status] ?? 'internal_error',
+    message: status === 500 ? 'Request failed. Please try again.' : error instanceof z.ZodError ? 'Invalid request parameters.' : (error as Error).message,
+    ...(error instanceof z.ZodError ? { issues: error.issues.map(({ path, message }) => ({ path, message })) } : {}),
+  } }, { status, headers: { ...headers, ...(status === 429 ? { 'Retry-After': '60' } : {}) } });
+}
+export async function limitRequest(repo: ContentRepository, address: string, write = false) {
+  const key = `mobile:${write ? 'write' : 'read'}:${await sha256Hex(address)}`;
+  if (!await repo.email.rateLimit(key, write ? 20 : 300, 60_000)) throw new ApiError(429, 'Too many requests. Try again in a minute.');
+}
+export function queryParams(url: URL) {
+  const result: Record<string, string> = {};
+  for (const [key, value] of url.searchParams) {
+    if (key in result) throw new ApiError(400, `Duplicate query parameter: ${key}.`);
+    result[key] = value;
+  }
+  return result;
+}
+export const pageQuery = {
+  page: z.coerce.number().int().min(1).max(10000).default(1),
+  limit: z.coerce.number().int().min(1).max(50).default(20),
+};
+export const isoDay = z.string().regex(/^\d{4}-\d{2}-\d{2}$/).refine((s) => {
+  const n = Date.parse(s); return Number.isFinite(n) && new Date(n).toISOString().slice(0, 10) === s;
+}, 'Use a valid calendar date.');
+
+export function methodNotAllowed(allow = 'GET, HEAD, OPTIONS') {
+  const res = failure(new ApiError(405, 'Method not allowed.'));
+  res.headers.set('Allow', allow);
+  return res;
+}

package/src/lib/mobile/route.ts

@@ -0,0 +1,20 @@
+import type { APIRoute } from 'astro';
+import type { ContentRepository } from '../repo/types';
+import { getRepo } from '../repo';
+import { limitRequest, failure, publicResponse, response } from './http';
+export function readRoute(load: (repo: ContentRepository, url: URL, id: string) => Promise<unknown>, cache = true): APIRoute {
+  return async context => {
+    try {
+      const repo = await getRepo(context.locals);
+      let address = 'unknown';
+      try { address = context.clientAddress || address; } catch { /* adapters without a client address share a bucket */ }
+      await limitRequest(repo, address);
+      const data = await load(repo, context.url, context.params.id ?? '');
+      const res = cache ? await publicResponse(context.request, data) : response(data);
+      return context.request.method === 'HEAD' ? new Response(null, { status: res.status, headers: res.headers }) : res;
+    } catch (error) {
+      const res = failure(error);
+      return context.request.method === 'HEAD' ? new Response(null, { status: res.status, headers: res.headers }) : res;
+    }
+  };
+}

package/src/lib/ops.ts

@@ -0,0 +1,8 @@
+import { timingSafeEqual } from 'node:crypto';
+import { runtimeValue } from './email/config';
+export function authorizedRunner(request: Request, locals?: unknown): boolean {
+  const expected = runtimeValue('EMAIL_RUNNER_SECRET', locals);
+  const supplied = request.headers.get('authorization')?.match(/^Bearer (.+)$/)?.[1] ?? '';
+  const a = Buffer.from(expected), b = Buffer.from(supplied);
+  return expected.length >= 32 && a.length === b.length && timingSafeEqual(a, b);
+}

package/src/lib/preview.ts

@@ -12,7 +12,7 @@ function sig(payload: string): string {
   return createHmac('sha256', secret).update(`preview.${payload}`).digest('hex');
 }
 
-export function createPreviewToken(type: 'post' | 'page', id: string, ttlMs = WEEK_MS): string {
+export function createPreviewToken(type: 'post' | 'page' | 'event', id: string, ttlMs = WEEK_MS): string {
   const exp = Date.now() + ttlMs;
   return `${exp}.${sig(`${type}.${id}.${exp}`)}`;
 }
@@ -26,3 +26,23 @@ export function verifyPreviewToken(type: string, id: string, token: string | und
   if (s.length !== expected.length) return false;
   return timingSafeEqual(Buffer.from(s), Buffer.from(expected));
 }
+
+// Design share links: ?preview=<token> opens preview mode for anyone holding
+// it. Token = <epoch>.<exp>.<sig>; `epoch` is the draft's shareEpoch, so
+// "Revoke all" (a fresh UUID) kills every earlier link, and publishing or
+// discarding the draft ends them all (no draft left to show).
+export function createDesignToken(epoch: string | number, ttlMs = WEEK_MS): { token: string; expiresAt: number } {
+  const exp = Date.now() + ttlMs;
+  return { token: `${epoch}.${exp}.${sig(`design.${epoch}.${exp}`)}`, expiresAt: exp };
+}
+
+// the token's expiry when valid for `epoch`, else null
+export function verifyDesignToken(token: string | undefined, epoch: string | number): number | null {
+  if (!token) return null;
+  const [epochStr, expStr, s] = token.split('.');
+  if (!epochStr || !expStr || !s) return null;
+  if (epochStr !== String(epoch) || !Number.isFinite(Number(expStr)) || Number(expStr) < Date.now() || epoch === 'legacy-disabled') return null;
+  const expected = sig(`design.${epochStr}.${expStr}`);
+  if (s.length !== expected.length) return null;
+  return timingSafeEqual(Buffer.from(s), Buffer.from(expected)) ? Number(expStr) : null;
+}

package/src/lib/repo/migrations.ts

@@ -1,3 +1,6 @@
+import { LIVE_MIGRATION } from '../live/migration';
+import { EMAIL_MIGRATION } from '../email/migration';
+import { WEBHOOK_MIGRATION } from '../webhook-sql';
 // Versioned schema migrations shared by the two SQLite-dialect adapters
 // (D1 and libSQL). Applied versions are recorded in the `migrations` table;
 // each adapter's runner applies whatever is newer, in order, at startup.
@@ -278,6 +281,224 @@ export const MIGRATIONS: Migration[] = [
     version: 25,
     statements: [`ALTER TABLE settings ADD COLUMN analytics TEXT DEFAULT '{}'`],
   },
+  {
+    version: 26,
+    statements: [
+      `ALTER TABLE settings ADD COLUMN ai TEXT NOT NULL DEFAULT '{}'`,
+      `ALTER TABLE settings ADD COLUMN agent TEXT NOT NULL DEFAULT '{}'`,
+    ],
+  },
+  {
+    // Calendar module: calendars (native + live ICS feeds), events with
+    // wall-clock times + recurrence, and the integration plumbing shared by
+    // events and (later) bookings: scoped API keys and signed webhooks with
+    // a retry queue. calendar_ids / tags / exdates / location / cta / fields
+    // are JSON columns, same as posts.tags. Event search rows reuse the
+    // search_index FTS table with kind = 'event'.
+    version: 27,
+    statements: [
+      `CREATE TABLE IF NOT EXISTS calendars (
+        id TEXT PRIMARY KEY,
+        slug TEXT UNIQUE NOT NULL,
+        name TEXT NOT NULL,
+        color TEXT NOT NULL DEFAULT '#4f46e5',
+        description TEXT NOT NULL DEFAULT '',
+        kind TEXT NOT NULL DEFAULT 'native',
+        feed_url TEXT NOT NULL DEFAULT '',
+        visibility TEXT NOT NULL DEFAULT 'public',
+        feed_token TEXT NOT NULL DEFAULT '',
+        ord INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )`,
+      `CREATE TABLE IF NOT EXISTS events (
+        id TEXT PRIMARY KEY,
+        slug TEXT UNIQUE NOT NULL,
+        title TEXT NOT NULL,
+        body_json TEXT NOT NULL DEFAULT '',
+        body_html TEXT NOT NULL DEFAULT '',
+        excerpt TEXT NOT NULL DEFAULT '',
+        cover TEXT NOT NULL DEFAULT '',
+        cover_alt TEXT NOT NULL DEFAULT '',
+        seo_title TEXT NOT NULL DEFAULT '',
+        seo_desc TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'draft',
+        featured INTEGER NOT NULL DEFAULT 0,
+        tags TEXT NOT NULL DEFAULT '[]',
+        template TEXT NOT NULL DEFAULT '',
+        starts TEXT NOT NULL,
+        ends TEXT NOT NULL DEFAULT '',
+        all_day INTEGER NOT NULL DEFAULT 0,
+        timezone TEXT NOT NULL DEFAULT '',
+        rrule TEXT NOT NULL DEFAULT '',
+        exdates TEXT NOT NULL DEFAULT '[]',
+        cancelled INTEGER NOT NULL DEFAULT 0,
+        location TEXT NOT NULL DEFAULT '{}',
+        cta TEXT NOT NULL DEFAULT '{}',
+        calendar_ids TEXT NOT NULL DEFAULT '[]',
+        fields TEXT NOT NULL DEFAULT '{}',
+        source_uid TEXT NOT NULL DEFAULT '',
+        start_at INTEGER NOT NULL,
+        end_at INTEGER NOT NULL,
+        draft TEXT,
+        published_at INTEGER,
+        scheduled_at INTEGER,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )`,
+      `CREATE INDEX IF NOT EXISTS events_start_at ON events (start_at)`,
+      `CREATE INDEX IF NOT EXISTS events_status ON events (status)`,
+      `CREATE TABLE IF NOT EXISTS api_keys (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        prefix TEXT NOT NULL,
+        key_hash TEXT UNIQUE NOT NULL,
+        scopes TEXT NOT NULL DEFAULT '[]',
+        last_used_at INTEGER,
+        created_at INTEGER NOT NULL
+      )`,
+      `CREATE TABLE IF NOT EXISTS webhooks (
+        id TEXT PRIMARY KEY,
+        url TEXT NOT NULL,
+        secret TEXT NOT NULL,
+        events TEXT NOT NULL DEFAULT '[]',
+        active INTEGER NOT NULL DEFAULT 1,
+        last_status INTEGER,
+        last_at INTEGER,
+        created_at INTEGER NOT NULL
+      )`,
+      `CREATE TABLE IF NOT EXISTS webhook_deliveries (
+        id TEXT PRIMARY KEY,
+        webhook_id TEXT NOT NULL,
+        event TEXT NOT NULL,
+        payload TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        attempts INTEGER NOT NULL DEFAULT 0,
+        next_at INTEGER,
+        response_code INTEGER,
+        created_at INTEGER NOT NULL,
+        delivered_at INTEGER
+      )`,
+      `CREATE INDEX IF NOT EXISTS webhook_deliveries_due ON webhook_deliveries (status, next_at)`,
+    ],
+  },
+  {
+    // Bookings: resources (rooms, people, vans…), their booking links, and the
+    // bookings themselves (also staff time blocks and event RSVPs). Weekly
+    // hours / overrides / questions are JSON. The (resource_id, start_at)
+    // index serves the overlap check every booking insert runs; hold_start /
+    // hold_end are the booked time widened by the link's buffers, so the
+    // overlap test is a single range comparison.
+    version: 28,
+    statements: [
+      `CREATE TABLE IF NOT EXISTS resources (
+        id TEXT PRIMARY KEY,
+        slug TEXT UNIQUE NOT NULL,
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL DEFAULT 'Room',
+        description TEXT NOT NULL DEFAULT '',
+        photo TEXT NOT NULL DEFAULT '',
+        capacity INTEGER,
+        amenities TEXT NOT NULL DEFAULT '[]',
+        timezone TEXT NOT NULL DEFAULT '',
+        hours TEXT NOT NULL DEFAULT '{}',
+        overrides TEXT NOT NULL DEFAULT '[]',
+        busy_feeds TEXT NOT NULL DEFAULT '[]',
+        notify_emails TEXT NOT NULL DEFAULT '[]',
+        visibility TEXT NOT NULL DEFAULT 'public',
+        show_on_calendar INTEGER NOT NULL DEFAULT 0,
+        feed_token TEXT NOT NULL DEFAULT '',
+        ord INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )`,
+      `CREATE TABLE IF NOT EXISTS booking_links (
+        id TEXT PRIMARY KEY,
+        resource_id TEXT NOT NULL,
+        slug TEXT NOT NULL,
+        name TEXT NOT NULL,
+        description TEXT NOT NULL DEFAULT '',
+        mode TEXT NOT NULL DEFAULT 'slots',
+        duration INTEGER NOT NULL DEFAULT 60,
+        lengths TEXT NOT NULL DEFAULT '[]',
+        min_days INTEGER NOT NULL DEFAULT 1,
+        max_days INTEGER NOT NULL DEFAULT 1,
+        step INTEGER NOT NULL DEFAULT 30,
+        buffer_before INTEGER NOT NULL DEFAULT 0,
+        buffer_after INTEGER NOT NULL DEFAULT 0,
+        min_notice INTEGER NOT NULL DEFAULT 120,
+        max_advance INTEGER NOT NULL DEFAULT 90,
+        per_day_cap INTEGER NOT NULL DEFAULT 0,
+        hours TEXT,
+        auto_confirm INTEGER NOT NULL DEFAULT 1,
+        visibility TEXT NOT NULL DEFAULT 'public',
+        ask_phone INTEGER NOT NULL DEFAULT 0,
+        questions TEXT NOT NULL DEFAULT '[]',
+        confirm_message TEXT NOT NULL DEFAULT '',
+        redirect_url TEXT NOT NULL DEFAULT '',
+        active INTEGER NOT NULL DEFAULT 1,
+        ord INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        UNIQUE (resource_id, slug)
+      )`,
+      `CREATE TABLE IF NOT EXISTS bookings (
+        id TEXT PRIMARY KEY,
+        kind TEXT NOT NULL DEFAULT 'booking',
+        resource_id TEXT NOT NULL DEFAULT '',
+        link_id TEXT NOT NULL DEFAULT '',
+        event_id TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL,
+        start_at INTEGER NOT NULL,
+        end_at INTEGER NOT NULL,
+        hold_start INTEGER NOT NULL,
+        hold_end INTEGER NOT NULL,
+        timezone TEXT NOT NULL DEFAULT '',
+        name TEXT NOT NULL DEFAULT '',
+        email TEXT NOT NULL DEFAULT '',
+        phone TEXT NOT NULL DEFAULT '',
+        seats INTEGER NOT NULL DEFAULT 1,
+        answers TEXT NOT NULL DEFAULT '{}',
+        notes TEXT NOT NULL DEFAULT '',
+        manage_token TEXT NOT NULL DEFAULT '',
+        source TEXT NOT NULL DEFAULT 'web',
+        reminder_sent_at INTEGER,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )`,
+      `CREATE INDEX IF NOT EXISTS bookings_resource_start ON bookings (resource_id, start_at)`,
+      `CREATE INDEX IF NOT EXISTS bookings_event_start ON bookings (event_id, start_at)`,
+      `CREATE INDEX IF NOT EXISTS bookings_manage ON bookings (manage_token)`,
+      `ALTER TABLE events ADD COLUMN rsvp TEXT NOT NULL DEFAULT '{}'`,
+    ],
+  },
+  EMAIL_MIGRATION,
+  { version: 30, statements: [
+    `CREATE TABLE mobile_booking_requests (key_hash TEXT PRIMARY KEY, request_hash TEXT NOT NULL, booking_id TEXT NOT NULL, created_at INTEGER NOT NULL)`,
+  ] },
+  // design history: every Publish design snapshots the outgoing live design
+  // (theme, overrides, brand images, navigation) so it can be restored
+  { version: 31, statements: [
+    `CREATE TABLE IF NOT EXISTS design_versions (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL,
+      author TEXT NOT NULL DEFAULT '',
+      summary TEXT NOT NULL DEFAULT '',
+      snapshot TEXT NOT NULL
+    )`,
+    `CREATE INDEX IF NOT EXISTS design_versions_created ON design_versions (created_at)`,
+  ] },
+  { version: 32, statements: [
+    `ALTER TABLE settings ADD COLUMN section_pages TEXT NOT NULL DEFAULT '{}'`,
+    `ALTER TABLE settings ADD COLUMN design_revision INTEGER NOT NULL DEFAULT 0`,
+    `CREATE TABLE IF NOT EXISTS design_audit (
+      id TEXT PRIMARY KEY, created_at INTEGER NOT NULL, actor TEXT NOT NULL,
+      action TEXT NOT NULL, expected_revision INTEGER NOT NULL,
+      actual_revision INTEGER NOT NULL CHECK (expected_revision = actual_revision)
+    )`,
+  ] },
+  WEBHOOK_MIGRATION,
+  LIVE_MIGRATION,
 ];
 
 export const LATEST_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;