@acms-subir/core 0.2.0 → 0.3.0

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,4 @@
+import { EMAIL_MIGRATION } from '../email/migration';
 // 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 +279,222 @@ 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)
+    )`,
+  ] },
 ];
 
 export const LATEST_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;