@acms-subir/core 0.3.3-next.20260929113209 → 0.3.4

package/src/lib/mobile/schemas.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { CalEvent, Booking, Calendar, BookingQuestion } from '../schema';
+
+const str = z.string(), bool = z.boolean(), strings = z.array(str);
+const date = str.datetime(), locale = str.nullable();
+export const Pagination = z.object({ page: z.number().int(), limit: z.number().int(), nextPage: z.number().int().nullable() });
+const Palette = z.object({ bg: str, ink: str, muted: str, line: str, accent: str, panel: str, soft: str });
+export const Site = z.object({
+  name: str, description: str, logo: str, icon: str, menu: z.array(z.object({ label: str, href: str })),
+  languages: z.object({ default: locale, locales: z.array(z.object({ code: str, name: str })) }),
+  features: z.object({ blog: z.array(z.object({ key: str, name: str, url: str })), calendar: bool, bookings: bool, search: bool }), apiVersion: z.literal(1),
+});
+export const Theme = z.object({
+  id: str, name: str, scheme: z.enum(['auto', 'light', 'dark']), colors: z.object({ light: Palette, dark: Palette }),
+  fonts: z.object({ heading: str, body: str, mono: str }), radius: z.enum(['sharp', 'soft', 'round', 'smooth']),
+});
+export const Section = z.object({ id: str, type: str, variant: str, data: z.record(z.unknown()) });
+export const ContentSummary = z.object({
+  id: str, kind: z.enum(['post', 'page']), slug: str, title: str, collection: str.nullable(), locale, url: str,
+  excerpt: str, tags: strings, image: str, imageAlt: str, publishedAt: date.nullable(), createdAt: date, updatedAt: date,
+});
+export const Html = z.object({ format: z.literal('sanitized-html'), html: str });
+export const Content = ContentSummary.extend({ content: Html.extend({ dynamicWidgets: z.literal('website-only') }) });
+export const Post = Content.extend({ kind: z.literal('post'), collection: str });
+export const Page = ContentSummary.extend({
+  kind: z.literal('page'), body: Html, cover: str, seo: z.object({ title: str, description: str }),
+  mode: z.enum(['content', 'sections']), sections: z.array(Section),
+});
+export const Event = CalEvent.pick({
+  id: true, slug: true, title: true, excerpt: true, status: true, cancelled: true, featured: true, start: true, end: true,
+  allDay: true, timezone: true, rrule: true, exdates: true, location: true, cta: true, tags: true, fields: true,
+}).extend({ url: str, icsUrl: str, repeats: str, image: str, imageAlt: str, updatedAt: date,
+  calendars: z.array(z.object({ id: str, slug: str, name: str, color: str })),
+});
+export const Events = z.object({ locale, timezone: str, from: date, to: date, pagination: Pagination,
+  occurrences: z.array(z.object({ id: str, start: date, end: date, allDay: bool, event: Event })),
+});
+export const Calendars = z.object({ calendars: z.array(Calendar.pick({ id: true, slug: true, name: true, color: true, description: true, kind: true, visibility: true }).extend({ feedUrl: str })) });
+export const Resources = z.object({ pagination: Pagination, resources: z.array(z.object({
+  id: str, slug: str, name: str, kind: str, description: str, capacity: z.number(), amenities: strings, photo: str, timezone: str, url: str,
+  links: z.array(z.object({ id: str, slug: str, name: str, description: str, mode: z.enum(['slots', 'day', 'range']), lengths: z.array(z.number()), rules: str,
+    askPhone: bool, autoConfirm: bool, url: str, questions: z.array(BookingQuestion.omit({ help: true })),
+  })),
+})) });
+export const Availability = z.object({ timezone: str, mode: z.enum(['slots', 'day', 'range']), lengths: z.array(z.number()), autoConfirm: bool,
+  days: z.array(z.object({ date: str, slots: z.array(z.object({ start: date, end: date, minutes: z.number() })) })),
+});
+export const BookingResult = z.object({ manageToken: str, booking: Booking.pick({
+  id: true, kind: true, status: true, name: true, email: true, phone: true, seats: true, answers: true, source: true,
+}).extend({ start: date, end: date, resourceId: str.nullable(), linkId: str.nullable(), eventId: str.nullable(), createdAt: date }) });
+export const Device = z.object({
+  token: str, platform: z.enum(['ios', 'android']), locale: str.nullable(), topics: strings, registeredAt: date, lastSeenAt: date,
+});
+export const DeviceRegistration = z.object({ created: bool, device: Device });
+export const DeviceRemoved = z.object({ token: str, deleted: z.literal(true) });
+export const PushTopics = z.object({ topics: z.array(z.object({ id: str, label: str, kind: z.enum(['general', 'collection', 'calendar']) })) });
+export const Error = z.object({ version: z.literal(1), error: z.object({
+  code: z.enum(['invalid_request', 'unauthorized', 'forbidden', 'not_found', 'method_not_allowed', 'conflict', 'gone', 'payload_too_large', 'unsupported_media_type', 'rate_limited', 'upstream_error', 'internal_error']),
+  message: str, issues: z.array(z.object({ path: z.array(z.union([str, z.number()])), message: str })).optional(),
+}) });

package/src/lib/mobile/site.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import type { ContentRepository } from '../repo/types';
+import { CONTENT } from '../content';
+import { I18N, localeName } from '../i18n';
+import { CALENDAR, bookingsEnabled } from '../calendar/config';
+import { SEARCH } from '../search-config';
+import { siteOrigin } from '../seo';
+import { resolveDesign } from '../theme';
+import { darkPalette } from '../themeTokens';
+import { safeUrl } from './content';
+import { queryParams } from './http';
+
+export async function getSite(repo: ContentRepository, url: URL) {
+  z.object({}).strict().parse(queryParams(url));
+  const [settings, nav, pages] = await Promise.all([repo.getSettings(), repo.listNavItems(), repo.listPages()]);
+  const origin = siteOrigin(settings, url);
+  const header = nav.filter(n => n.area === 'header').sort((a, b) => a.order - b.order);
+  const menu = header.length ? header : [
+    { label: 'Home', url: '/' },
+    ...pages.filter(p => p.status === 'published' && !p.isHome).map(p => ({ label: p.title, url: `/${p.slug}` })),
+    ...Object.values(CONTENT.collections).map(c => ({ label: c.plural, url: c.base })),
+    { label: 'Links', url: '/links' },
+  ];
+  return {
+    name: settings.siteTitle, description: settings.tagline,
+    logo: safeUrl(settings.siteLogo, origin), icon: safeUrl(settings.siteFavicon, origin),
+    menu: menu.map(n => ({ label: n.label, href: safeUrl(n.url, origin, true) })),
+    languages: { default: I18N.defaultLocale || null, locales: I18N.locales.map(code => ({ code, name: localeName(code, true) })) },
+    features: { blog: Object.entries(CONTENT.collections).map(([key, c]) => ({ key, name: c.plural, url: safeUrl(c.base, origin) })), calendar: CALENDAR.enabled, bookings: bookingsEnabled(), search: SEARCH.enabled },
+    apiVersion: 1,
+  };
+}
+export async function getThemeTokens(repo: ContentRepository, url: URL) {
+  z.object({}).strict().parse(queryParams(url));
+  const { theme, tokens: t } = resolveDesign(await repo.getSettings());
+  return {
+    id: theme.slug, name: theme.name, scheme: t.scheme,
+    colors: { light: { bg: t.bg, ink: t.ink, muted: t.muted, line: t.line, accent: t.accent, panel: t.panel, soft: t.soft }, dark: darkPalette(t) },
+    fonts: { heading: t.headingFont, body: t.bodyFont, mono: t.monoFont }, radius: t.radius,
+  };
+}

package/src/lib/push/api.ts

@@ -0,0 +1,158 @@
+// Public device endpoints (/api/v1/devices, /api/v1/push/topics) and the
+// owner-only admin state/actions behind Admin → Mobile app.
+import { z } from 'zod';
+import type { ContentRepository } from '../repo/types';
+import { ApiError, readJson } from '../api';
+import { sha256Hex } from '../api-keys';
+import { CONTENT, collectionUrl } from '../content';
+import { CALENDAR, eventUrl } from '../calendar/config';
+import { eventIsListed } from '../calendar/events';
+import { queryParams } from '../mobile/http';
+import { EXPO_PUSH_BASE, PUSH, requirePush } from './config';
+import { expoOptions } from './expo';
+import { knownTopics, pushTopics, sendNotification, siteOriginOf, type PushRunOptions } from './service';
+import { PushAuto, type PushDevice } from './types';
+
+export const pushToken = z.string().max(250).regex(/^Expo(?:nent)?PushToken\[[A-Za-z0-9_-]{8,200}\]$/, 'Use an Expo push token such as ExponentPushToken[…].');
+const topicList = z.array(z.string().min(1).max(200).regex(/^[a-z0-9][a-z0-9:_-]*$/i, 'Use topic ids from GET /api/v1/push/topics.')).max(50);
+const locale = z.string().max(35).regex(/^[A-Za-z]{2,3}(?:[-_][A-Za-z0-9]{1,8})*$/, 'Use a language tag such as en or es-MX.');
+export const deviceInput = z.object({
+  token: pushToken,
+  platform: z.enum(['ios', 'android']),
+  locale: locale.optional(),
+  /** Replaces the device's topics. Omit to keep them (new devices start with none). */
+  topics: topicList.optional(),
+}).strict();
+export const deviceUpdate = z.object({ locale: locale.optional(), topics: topicList.optional() }).strict();
+
+export const deviceJson = (d: PushDevice) => ({
+  token: d.token, platform: d.platform, locale: d.locale || null, topics: d.topics,
+  registeredAt: new Date(d.createdAt).toISOString(), lastSeenAt: new Date(d.lastSeenAt).toISOString(),
+});
+const deviceId = (token: string) => sha256Hex(`expo-push:${token}`);
+
+async function checkTopics(repo: ContentRepository, topics: string[] | undefined) {
+  if (!topics) return undefined;
+  const known = await knownTopics(repo);
+  const unique = [...new Set(topics)];
+  const unknown = unique.find((t) => !known.has(t));
+  if (unknown) throw new ApiError(400, `Unknown topic: ${unknown}. See GET /api/v1/push/topics.`);
+  return unique;
+}
+function tokenParam(raw: string) {
+  let value = raw;
+  try { if (/%[0-9a-f]{2}/i.test(raw)) value = decodeURIComponent(raw); } catch { /* keep raw */ }
+  const parsed = pushToken.safeParse(value);
+  if (!parsed.success) throw new ApiError(400, 'Use an Expo push token such as ExponentPushToken[…] in the path.');
+  return parsed.data;
+}
+
+export async function registerDevice(repo: ContentRepository, request: Request) {
+  requirePush();
+  const body = deviceInput.parse(await readJson(request, 8_000));
+  const topics = await checkTopics(repo, body.topics);
+  const { device, created } = await repo.push.upsertDevice({ id: await deviceId(body.token), token: body.token, platform: body.platform, locale: body.locale ?? '', topics }, Date.now());
+  return { created, device: deviceJson(device) };
+}
+export async function updateDevice(repo: ContentRepository, request: Request, rawToken: string) {
+  requirePush();
+  const token = tokenParam(rawToken);
+  const body = deviceUpdate.parse(await readJson(request, 8_000));
+  if (body.locale === undefined && body.topics === undefined) throw new ApiError(400, 'Send topics, locale or both.');
+  const device = await repo.push.updateDevice(await deviceId(token), { locale: body.locale, topics: await checkTopics(repo, body.topics) }, Date.now());
+  if (!device) throw new ApiError(404, 'This device is not registered. Register it with POST /api/v1/devices.');
+  return deviceJson(device);
+}
+export async function unregisterDevice(repo: ContentRepository, rawToken: string) {
+  requirePush();
+  const token = tokenParam(rawToken);
+  // idempotent: an unknown token is already opted out
+  await repo.push.deleteDevices([await deviceId(token)]);
+  return { token, deleted: true };
+}
+export async function listPushTopics(repo: ContentRepository, url: URL) {
+  requirePush();
+  z.object({}).strict().parse(queryParams(url));
+  return { topics: await pushTopics(repo) };
+}
+
+// ---- admin -------------------------------------------------------------------
+
+export interface PushLinkTarget { ref: string; label: string; url: string; group: 'Pages' | 'Posts' | 'Events' }
+async function linkTargets(repo: ContentRepository): Promise<PushLinkTarget[]> {
+  const [pages, posts, events, calendars] = await Promise.all([
+    repo.listPages(), repo.listPublishedPosts(),
+    CALENDAR.enabled ? repo.listPublishedEvents() : Promise.resolve([]),
+    CALENDAR.enabled ? repo.listCalendars() : Promise.resolve([]),
+  ]);
+  const cals = new Map(calendars.map((c) => [c.id, c]));
+  return [
+    ...pages.filter((p) => p.status === 'published').map((p): PushLinkTarget => ({ ref: `page:${p.id}`, label: p.title || p.slug, url: p.isHome ? '/' : `/${p.slug}`, group: 'Pages' })),
+    ...posts.filter((p) => CONTENT.collections[p.collection]).slice(0, 200).map((p): PushLinkTarget => ({ ref: `post:${p.id}`, label: p.title, url: collectionUrl(p.collection, p.slug), group: 'Posts' })),
+    ...events.filter((e) => eventIsListed(e, cals)).slice(0, 200).map((e): PushLinkTarget => ({ ref: `event:${e.id}`, label: e.title, url: eventUrl(e.slug), group: 'Events' })),
+  ];
+}
+
+export async function adminPushState(repo: ContentRepository, url: URL, locals?: unknown) {
+  const now = Date.now();
+  const settings = await repo.getSettings();
+  const expo = expoOptions(locals);
+  const [stats, topics, calendars, links, log] = await Promise.all([
+    repo.push.stats(now), pushTopics(repo),
+    CALENDAR.enabled ? repo.listCalendars() : Promise.resolve([]),
+    linkTargets(repo), repo.push.listNotifications(50),
+  ]);
+  return {
+    enabled: PUSH.enabled, retentionDays: PUSH.retentionDays,
+    site: { name: settings.siteTitle, icon: settings.siteFavicon, origin: siteOriginOf(settings, url.origin) },
+    stats, topics, auto: settings.push.auto, links, log,
+    collections: Object.entries(CONTENT.collections).map(([key, c]) => ({ key, label: c.plural })),
+    calendarEnabled: CALENDAR.enabled,
+    calendars: calendars.filter((c) => c.visibility === 'public').map((c) => ({ id: c.id, slug: c.slug, name: c.name, color: c.color })),
+    expo: { accessToken: Boolean(expo.accessToken), customEndpoint: expo.base !== EXPO_PUSH_BASE },
+  };
+}
+export type AdminPushState = Awaited<ReturnType<typeof adminPushState>>;
+
+const audience = z.array(z.string().min(1).max(200)).min(1, 'Choose who gets it.').max(50);
+const link = z.string().trim().max(2000).refine((v) => !v || (/^\/(?!\/)/.test(v) || /^https?:\/\//i.test(v)), 'Use a site path such as /events or a full https:// address.');
+export const AdminPushInput = z.discriminatedUnion('action', [
+  z.object({ action: z.literal('count'), audience }).strict(),
+  z.object({ action: z.literal('send'), title: z.string().trim().min(1, 'Add a title.').max(80), body: z.string().trim().max(240).default(''), url: link.default(''), audience }).strict(),
+  z.object({ action: z.literal('saveAuto'), auto: PushAuto }).strict(),
+]);
+
+async function checkAudience(repo: ContentRepository, list: string[]) {
+  if (list.includes('*')) return ['*'];
+  const known = await knownTopics(repo);
+  const bad = list.find((t) => !known.has(t));
+  if (bad) throw new ApiError(400, `Unknown topic: ${bad}.`);
+  return [...new Set(list)];
+}
+
+export async function adminPushAction(repo: ContentRepository, input: z.infer<typeof AdminPushInput>, ctx: { url: URL; locals?: unknown; author: string; run?: PushRunOptions }) {
+  switch (input.action) {
+    case 'count':
+      return { recipients: await repo.push.countAudience(await checkAudience(repo, input.audience)) };
+    case 'send': {
+      const settings = await repo.getSettings();
+      const notification = await sendNotification(repo, {
+        title: input.title, body: input.body, url: input.url, audience: await checkAudience(repo, input.audience),
+        source: 'manual', author: ctx.author,
+      }, { locals: ctx.locals, origin: siteOriginOf(settings, ctx.url.origin), ...ctx.run });
+      return { notification };
+    }
+    case 'saveAuto': {
+      const collections = new Set(Object.keys(CONTENT.collections));
+      const calendars = new Set((CALENDAR.enabled ? await repo.listCalendars() : []).filter((c) => c.visibility === 'public').map((c) => c.id));
+      const cals = (ids: string[]) => [...new Set(ids)].filter((id) => id === '*' || calendars.has(id));
+      const auto = {
+        newPost: { collections: [...new Set(input.auto.newPost.collections)].filter((k) => collections.has(k)) },
+        newEvent: { calendars: CALENDAR.enabled ? cals(input.auto.newEvent.calendars) : [] },
+        startingSoon: { calendars: CALENDAR.enabled ? cals(input.auto.startingSoon.calendars) : [], minutes: input.auto.startingSoon.minutes },
+      };
+      await repo.updateSettings({ push: { auto } });
+      return { auto };
+    }
+  }
+}

package/src/lib/push/config.ts

@@ -0,0 +1,20 @@
+// Push notifications config, set per project via the integration:
+//   acms({ mobile: { push: true } })  or  { push: { enabled: true, retentionDays: 270 } }
+// Off by default. When off, the device/topic endpoints and the admin Mobile
+// app page are not registered at all (like other disabled modules), and the
+// scheduler just marks any queued automatic notifications as skipped.
+import { userConfig } from 'virtual:acms-config';
+import { ApiError } from '../api';
+
+// mutable so tests can exercise the disabled paths
+export const PUSH = {
+  enabled: userConfig.mobile?.push?.enabled === true,
+  retentionDays: userConfig.mobile?.push?.retentionDays ?? 270,
+};
+
+export function requirePush() {
+  if (!PUSH.enabled) throw new ApiError(404, 'This feature is disabled.');
+}
+
+/** Expo's push service. ACMS_EXPO_PUSH_URL overrides it (a local stub in tests/QA). */
+export const EXPO_PUSH_BASE = 'https://exp.host/--/api/v2/push';

package/src/lib/push/expo.ts

@@ -0,0 +1,76 @@
+// Expo push service client: https://docs.expo.dev/push-notifications/sending-notifications/
+// send: POST <base>/send with up to 100 messages → one ticket per message, in order.
+// receipts: POST <base>/getReceipts with up to 1000 ticket ids, some minutes later.
+// An Expo access token (EXPO_ACCESS_TOKEN) is only needed when "enhanced push
+// security" is on for the Expo project. ACMS_EXPO_PUSH_URL points the sender at
+// a stub for tests and local QA.
+import { runtimeValue } from '../email/config';
+import { EXPO_PUSH_BASE } from './config';
+
+export interface ExpoMessage {
+  to: string; title: string; body: string; data: Record<string, unknown>;
+  sound?: 'default' | null; priority?: 'default' | 'normal' | 'high'; channelId?: string;
+}
+export type ExpoTicket = { status: 'ok'; id: string } | { status: 'error'; message: string; details?: { error?: string } };
+export type ExpoReceipt = { status: 'ok' } | { status: 'error'; message: string; details?: { error?: string } };
+export type Fetcher = (url: string, init: RequestInit) => Promise<Response>;
+export interface ExpoOptions { base: string; accessToken: string; fetcher?: Fetcher; retryDelayMs?: number }
+
+export const SEND_BATCH = 100;
+export const RECEIPT_BATCH = 1000;
+
+export function expoOptions(locals?: unknown, extra: Partial<ExpoOptions> = {}): ExpoOptions {
+  const base = (runtimeValue('ACMS_EXPO_PUSH_URL', locals) || EXPO_PUSH_BASE).replace(/\/+$/, '');
+  return { base, accessToken: runtimeValue('EXPO_ACCESS_TOKEN', locals), ...extra };
+}
+
+async function post(opts: ExpoOptions, path: string, body: unknown): Promise<{ ok: true; json: any } | { ok: false; message: string }> {
+  const fetcher: Fetcher = opts.fetcher ?? ((url, init) => fetch(url, init));
+  const headers: Record<string, string> = { 'content-type': 'application/json', accept: 'application/json', 'user-agent': 'acms-push/1.0' };
+  if (opts.accessToken) headers.authorization = `Bearer ${opts.accessToken}`;
+  let last = 'Push service unreachable.';
+  // one retry for rate limits, server errors and network failures
+  for (let attempt = 0; attempt < 2; attempt++) {
+    if (attempt) await new Promise((r) => setTimeout(r, opts.retryDelayMs ?? 1500));
+    try {
+      const res = await fetcher(`${opts.base}${path}`, { method: 'POST', headers, body: JSON.stringify(body), signal: AbortSignal.timeout(15_000) });
+      const json = await res.json().catch(() => null);
+      if (res.ok && json && typeof json === 'object') return { ok: true, json };
+      last = json?.errors?.[0]?.message ?? `Push service answered ${res.status}.`;
+      if (res.status !== 429 && res.status < 500) break;
+    } catch (e) {
+      last = e instanceof Error && e.name === 'TimeoutError' ? 'Push service timed out.' : 'Push service unreachable.';
+    }
+  }
+  return { ok: false, message: last };
+}
+
+/** One ticket per message, aligned by index. A failed batch yields error tickets for each of its messages. */
+export async function sendMessages(messages: ExpoMessage[], opts: ExpoOptions): Promise<ExpoTicket[]> {
+  const tickets: ExpoTicket[] = [];
+  for (let i = 0; i < messages.length; i += SEND_BATCH) {
+    const batch = messages.slice(i, i + SEND_BATCH);
+    const res = await post(opts, '/send', batch);
+    const data = res.ok && Array.isArray(res.json.data) ? res.json.data : null;
+    for (let j = 0; j < batch.length; j++) {
+      const t = data?.[j];
+      if (t?.status === 'ok' && typeof t.id === 'string') tickets.push({ status: 'ok', id: t.id });
+      else if (t?.status === 'error') tickets.push({ status: 'error', message: String(t.message ?? 'Rejected.'), details: t.details });
+      else tickets.push({ status: 'error', message: res.ok ? 'No ticket returned.' : res.message, details: { error: 'RequestFailed' } });
+    }
+  }
+  return tickets;
+}
+
+/** Receipts by ticket id. Ids Expo doesn't know yet (or anymore) are simply missing. */
+export async function fetchReceipts(ids: string[], opts: ExpoOptions): Promise<Record<string, ExpoReceipt>> {
+  const out: Record<string, ExpoReceipt> = {};
+  for (let i = 0; i < ids.length; i += RECEIPT_BATCH) {
+    const res = await post(opts, '/getReceipts', { ids: ids.slice(i, i + RECEIPT_BATCH) });
+    if (!res.ok) throw new Error(res.message);
+    Object.assign(out, res.json.data ?? {});
+  }
+  return out;
+}
+
+export const isGone = (x: { status: string; details?: { error?: string } }) => x.status === 'error' && x.details?.error === 'DeviceNotRegistered';

package/src/lib/push/migration.ts

@@ -0,0 +1,60 @@
+// v37: push notifications. Devices hold the Expo push token (needed to send)
+// and nothing personal. push_queue doubles as the "already announced" ledger:
+// one row per post/event ever published (key post:<id> / event:<id>) and per
+// "starting soon" occurrence (soon:<id>:<start ms>), so automatic notices go
+// out on the FIRST publish only, never for edits or re-publishing.
+//
+// Rows are written by triggers, so every publish path (editor, scheduled
+// publishing, API, agent) is covered without touching each caller. Imports and
+// restores run with webhook_control.suppressed=1 and are recorded as skipped:
+// migrating old posts is not news. The scheduler decides whether a pending row
+// is actually sent (push enabled, matching automatic rule, still published).
+const now = "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
+const status = "CASE WHEN (SELECT suppressed FROM webhook_control WHERE id=1)=1 THEN 'skipped' ELSE 'pending' END";
+function enqueue(kind: 'post' | 'event') {
+  // Plain INSERT … SELECT … WHERE NOT EXISTS: no conflict clause, so an outer
+  // INSERT OR REPLACE (restore) can't turn it into a replace of a sent row.
+  return `INSERT INTO push_queue (key,kind,doc_id,occurrence,status,notification_id,created_at,updated_at)
+    SELECT '${kind}:'||NEW.id,'${kind}',NEW.id,NULL,${status},NULL,${now},${now}
+    WHERE NOT EXISTS (SELECT 1 FROM push_queue WHERE key='${kind}:'||NEW.id);`;
+}
+function triggers(kind: 'post' | 'event') {
+  const table = `${kind}s`;
+  return [
+    `CREATE TRIGGER push_${kind}_insert AFTER INSERT ON ${table} WHEN NEW.status='published' BEGIN ${enqueue(kind)} END`,
+    `CREATE TRIGGER push_${kind}_publish AFTER UPDATE OF status ON ${table}
+      WHEN NEW.status='published' AND OLD.status IS NOT 'published' BEGIN ${enqueue(kind)} END`,
+  ];
+}
+
+export const PUSH_MIGRATION = { version: 37, statements: [
+  `ALTER TABLE settings ADD COLUMN push TEXT NOT NULL DEFAULT '{}'`,
+  `CREATE TABLE push_devices (
+    id TEXT PRIMARY KEY, token TEXT NOT NULL UNIQUE, platform TEXT NOT NULL,
+    locale TEXT NOT NULL DEFAULT '', topics TEXT NOT NULL DEFAULT '[]',
+    created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, last_seen_at INTEGER NOT NULL
+  )`,
+  `CREATE INDEX push_devices_seen ON push_devices (last_seen_at)`,
+  `CREATE TABLE push_notifications (
+    id TEXT PRIMARY KEY, title TEXT NOT NULL, body TEXT NOT NULL DEFAULT '', url TEXT NOT NULL DEFAULT '',
+    topics TEXT NOT NULL DEFAULT '[]', source TEXT NOT NULL DEFAULT 'manual', source_key TEXT NOT NULL DEFAULT '',
+    status TEXT NOT NULL DEFAULT 'sending', recipients INTEGER NOT NULL DEFAULT 0, sent INTEGER NOT NULL DEFAULT 0,
+    ok INTEGER NOT NULL DEFAULT 0, failed INTEGER NOT NULL DEFAULT 0, removed INTEGER NOT NULL DEFAULT 0,
+    error TEXT NOT NULL DEFAULT '', author TEXT NOT NULL DEFAULT '', created_at INTEGER NOT NULL, finished_at INTEGER
+  )`,
+  `CREATE INDEX push_notifications_created ON push_notifications (created_at)`,
+  // Expo push tickets awaiting a receipt check (receipts expire after 24h)
+  `CREATE TABLE push_tickets (id TEXT PRIMARY KEY, notification_id TEXT NOT NULL, device_id TEXT NOT NULL, created_at INTEGER NOT NULL)`,
+  `CREATE INDEX push_tickets_created ON push_tickets (created_at)`,
+  `CREATE TABLE push_queue (
+    key TEXT PRIMARY KEY, kind TEXT NOT NULL, doc_id TEXT NOT NULL, occurrence INTEGER,
+    status TEXT NOT NULL, notification_id TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+  )`,
+  `CREATE INDEX push_queue_status ON push_queue (status, created_at)`,
+  // everything already live counts as announced
+  `INSERT INTO push_queue (key,kind,doc_id,occurrence,status,notification_id,created_at,updated_at)
+    SELECT 'post:'||id,'post',id,NULL,'seen',NULL,${now},${now} FROM posts WHERE status='published'`,
+  `INSERT INTO push_queue (key,kind,doc_id,occurrence,status,notification_id,created_at,updated_at)
+    SELECT 'event:'||id,'event',id,NULL,'seen',NULL,${now},${now} FROM events WHERE status='published'`,
+  ...triggers('post'), ...triggers('event'),
+] };