@trypattern/sdk 0.1.33 → 0.1.34

package/dist/server/requests.js

@@ -0,0 +1,328 @@
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { REQUESTS_ACT, verifiedAssertion } from "../patternAccess.js";
+import { REQUEST_SYNC_PAGE, requestAct, requestBound, requestCard } from "../requests.js";
+import { ServiceRefused, refused } from "../services.js";
+import { authServiceFor } from "./authService.js";
+import { PATTERN_KEYS } from "./patternKeys.js";
+import { bearerOf } from "./patternViewer.js";
+const DASHBOARD = 'https://onpattern.app';
+const MAX_ATTEMPTS = 8;
+const STALE_CLAIM_MS = 5 * 60 * 1000;
+const BACKOFF_MINUTES = [1, 5, 30, 120, 720];
+const DRAINED_AT_ONCE = 10;
+const CHANGED = 'This request changed since you opened it. Open it again to see what’s new.';
+const REQUEST_TABLES = [
+    'request_states',
+    'request_events',
+    'request_outbox',
+    'request_operations'
+];
+const NOT_MIGRATED = 'This site’s database doesn’t have Pattern’s request tables yet: run app migration, then publish';
+const migrated = new WeakMap();
+export function takesRequests(d1) {
+    const known = migrated.get(d1);
+    if (known !== undefined)
+        return known;
+    const found = d1
+        .prepare("SELECT COUNT(*) AS count FROM sqlite_master WHERE type = 'table' AND name IN (SELECT value FROM json_each(?1))")
+        .bind(JSON.stringify(REQUEST_TABLES))
+        .first()
+        .then((row) => Number(row?.count ?? 0) === REQUEST_TABLES.length);
+    migrated.set(d1, found);
+    return found;
+}
+export const NEXT_SEQUENCE = '(SELECT COALESCE(MAX(sequence), 0) + 1 FROM request_states)';
+function stateId(source, requestId) {
+    return `${source}:${requestId}`;
+}
+export function requestsLink(env) {
+    const name = env.APP_NAME ?? '';
+    return name === '' ? DASHBOARD : `${DASHBOARD}/sites/${name}/requests`;
+}
+export function receivedStatements(d1, { source, table, requestId, notice }) {
+    const guard = `WHERE EXISTS (SELECT 1 FROM ${table} WHERE id = ?3)`;
+    const now = new Date().toISOString();
+    return [
+        d1
+            .prepare(`INSERT INTO request_states (id, source, request_id, state, revision, sequence, updated_at) SELECT ?1, ?2, ?3, 'open', 1, ${NEXT_SEQUENCE}, ?4 ${guard}`)
+            .bind(stateId(source, requestId), source, requestId, now),
+        d1
+            .prepare(`INSERT INTO request_events (id, source, request_id, kind) SELECT ?1, ?2, ?3, 'received' ${guard}`)
+            .bind(crypto.randomUUID(), source, requestId),
+        d1
+            .prepare(`INSERT INTO request_outbox (id, source, request_id, subject, text, reply_to, status, attempts, next_at, sent_at, claimed_at) SELECT ?1, ?2, ?3, ?4, ?5, ?6, 'pending', 0, NULL, NULL, NULL ${guard}`)
+            .bind(crypto.randomUUID(), source, requestId, notice.subject, notice.text, notice.replyTo)
+    ];
+}
+export function transitionStatements(d1, { source, requestId, event, state, expected }) {
+    const id = stateId(source, requestId);
+    const guard = expected === null
+        ? ''
+        : `WHERE (SELECT revision FROM request_states WHERE id = ?4) = ?5`;
+    return [
+        d1
+            .prepare(`INSERT INTO request_events (id, source, request_id, kind) SELECT ?1, ?2, ?3, '${event}' ${guard}`)
+            .bind(crypto.randomUUID(), source, requestId, ...(expected === null ? [] : [id, expected])),
+        d1
+            .prepare(`UPDATE request_states SET state = ?1, revision = revision + 1, sequence = ${NEXT_SEQUENCE}, updated_at = ?2 WHERE id = ?3${expected === null ? '' : ' AND revision = ?4'}`)
+            .bind(state, new Date().toISOString(), id, ...(expected === null ? [] : [expected]))
+    ];
+}
+function touchStatement(d1, source, requestId) {
+    return d1
+        .prepare(`UPDATE request_states SET sequence = ${NEXT_SEQUENCE} WHERE id = ?1`)
+        .bind(stateId(source, requestId));
+}
+function nextTry(attempts, now) {
+    const minutes = BACKOFF_MINUTES[Math.min(attempts - 1, BACKOFF_MINUTES.length - 1)] ?? 720;
+    return new Date(now + minutes * 60_000).toISOString();
+}
+async function deliver(env, row) {
+    const service = authServiceFor(env);
+    try {
+        return ((await service?.noteOwner({
+            subject: row.subject,
+            text: row.text,
+            ...(row.reply_to === '' ? {} : { replyTo: row.reply_to }),
+            key: row.id
+        })) ?? false);
+    }
+    catch {
+        return false;
+    }
+}
+export async function drainNotices(env, { force = false } = {}) {
+    const d1 = env.DB;
+    const now = Date.now();
+    const nowText = new Date(now).toISOString();
+    const stale = new Date(now - STALE_CLAIM_MS).toISOString();
+    const claimable = `(status = 'pending' OR (status = 'failed' AND attempts < ${MAX_ATTEMPTS} AND (?1 = 1 OR next_at <= ?2)) OR (status = 'sending' AND claimed_at < ?3))`;
+    const { results } = await d1
+        .prepare(`SELECT id, source, request_id, subject, text, reply_to, status, attempts FROM request_outbox WHERE ${claimable} ORDER BY created_at LIMIT ${DRAINED_AT_ONCE}`)
+        .bind(force ? 1 : 0, nowText, stale)
+        .all();
+    for (const row of results) {
+        const claimed = await d1
+            .prepare(`UPDATE request_outbox SET status = 'sending', claimed_at = ?4 WHERE id = ?5 AND ${claimable}`)
+            .bind(force ? 1 : 0, nowText, stale, nowText, row.id)
+            .run();
+        if (claimed.meta.changes !== 1)
+            continue;
+        const sent = await deliver(env, row);
+        const attempts = row.attempts + 1;
+        await d1.batch([
+            d1
+                .prepare('UPDATE request_outbox SET status = ?1, attempts = ?2, sent_at = ?3, next_at = ?4, claimed_at = NULL WHERE id = ?5')
+                .bind(sent ? 'sent' : 'failed', attempts, sent ? new Date().toISOString() : null, sent ? null : nextTry(attempts, Date.now()), row.id),
+            touchStatement(d1, row.source, row.request_id)
+        ]);
+    }
+}
+export function afterResponse(c, work) {
+    try {
+        c.executionCtx.waitUntil(work);
+        return Promise.resolve();
+    }
+    catch {
+        return work.then(() => undefined, () => undefined);
+    }
+}
+async function cardsOf(d1, sources, states) {
+    if (states.length === 0)
+        return [];
+    const keys = JSON.stringify(states.map((state) => state.id));
+    const [events, notices] = await Promise.all([
+        d1
+            .prepare("SELECT source, request_id, kind, created_at FROM request_events WHERE source || ':' || request_id IN (SELECT value FROM json_each(?1)) ORDER BY created_at")
+            .bind(keys)
+            .all(),
+        d1
+            .prepare("SELECT source, request_id, status, attempts, sent_at, created_at FROM request_outbox WHERE source || ':' || request_id IN (SELECT value FROM json_each(?1)) ORDER BY created_at")
+            .bind(keys)
+            .all()
+    ]);
+    const cards = [];
+    for (const source of sources) {
+        const mine = states.filter((state) => state.source === source.name);
+        if (mine.length === 0)
+            continue;
+        const contents = await source.contents(d1, new Map(mine.map((state) => [
+            state.request_id,
+            {
+                state: state.state,
+                replied: events.results.some((event) => event.kind === 'replied' &&
+                    event.source === state.source &&
+                    event.request_id === state.request_id)
+            }
+        ])));
+        for (const state of mine) {
+            const content = contents.get(state.request_id);
+            if (content === undefined)
+                continue;
+            const of = (row) => row.source === state.source && row.request_id === state.request_id;
+            const notice = notices.results.filter(of).at(-1);
+            cards.push({
+                ...content,
+                source: state.source,
+                id: state.request_id,
+                revision: Number(state.revision),
+                history: events.results
+                    .filter(of)
+                    .map((event) => ({ kind: event.kind, at: event.created_at })),
+                notice: notice === undefined
+                    ? null
+                    : {
+                        status: notice.status,
+                        attempts: Number(notice.attempts),
+                        at: notice.sent_at
+                    }
+            });
+        }
+    }
+    return cards;
+}
+async function readStates(d1, after) {
+    const { results } = await d1
+        .prepare(`SELECT id, source, request_id, state, revision, sequence FROM request_states WHERE sequence > ?1 ORDER BY sequence LIMIT ${REQUEST_SYNC_PAGE}`)
+        .bind(after)
+        .all();
+    return results;
+}
+async function cardOf(d1, sources, source, requestId) {
+    const state = await d1
+        .prepare('SELECT id, source, request_id, state, revision, sequence FROM request_states WHERE id = ?1')
+        .bind(stateId(source, requestId))
+        .first();
+    if (state === null)
+        return undefined;
+    const [card] = await cardsOf(d1, sources, [state]);
+    return card;
+}
+function requirePattern(c) {
+    const viewer = c.get('viewer');
+    if (viewer === null || !viewer.userId.startsWith('pattern:')) {
+        throw refused(401, 'Signed out');
+    }
+}
+async function sync(c, sources) {
+    requirePattern(c);
+    if (!(await takesRequests(c.env.DB)))
+        throw refused(404, NOT_MIGRATED);
+    const after = z.coerce
+        .number()
+        .int()
+        .min(0)
+        .catch(0)
+        .parse(c.req.query('after'));
+    await drainNotices(c.env, { force: c.req.query('deliver') === 'now' });
+    const backfills = sources.flatMap((source) => source.backfill === undefined ? [] : [source.backfill(c.env.DB)]);
+    if (backfills.length > 0)
+        await c.env.DB.batch(backfills);
+    const states = await readStates(c.env.DB, after);
+    return {
+        cursor: states.reduce((highest, state) => Math.max(highest, Number(state.sequence)), after),
+        requests: await cardsOf(c.env.DB, sources, states)
+    };
+}
+async function remembered(d1, operation) {
+    const row = await d1
+        .prepare('SELECT result FROM request_operations WHERE id = ?1')
+        .bind(operation)
+        .first();
+    if (row === null || row.result === '')
+        return undefined;
+    const card = requestCard.safeParse(JSON.parse(row.result));
+    return card.success ? card.data : undefined;
+}
+async function actionStatements(d1, source, act) {
+    const base = { source: act.source, requestId: act.id, expected: act.revision };
+    if (act.action === 'reply') {
+        return transitionStatements(d1, {
+            ...base,
+            event: 'replied',
+            state: 'open'
+        });
+    }
+    if (act.action === 'done') {
+        return transitionStatements(d1, { ...base, event: 'done', state: 'done' });
+    }
+    if (source.decide === undefined)
+        throw refused(400, 'Not allowed');
+    return source.decide(d1, act.id, act.action, act.revision);
+}
+async function act(c, sources) {
+    requirePattern(c);
+    if (!(await takesRequests(c.env.DB)))
+        throw refused(404, NOT_MIGRATED);
+    const parsed = requestAct.safeParse(await c.req.json().catch(() => null));
+    if (!parsed.success)
+        throw refused(400, z.prettifyError(parsed.error));
+    const wanted = parsed.data;
+    const email = await verifiedAssertion(bearerOf(c) ?? '', {
+        hostname: new URL(c.req.url).hostname,
+        keys: PATTERN_KEYS,
+        now: Math.floor(Date.now() / 1000),
+        scope: REQUESTS_ACT,
+        bound: await requestBound(wanted)
+    });
+    if (email === undefined)
+        throw refused(403, 'This pass is for another action');
+    const d1 = c.env.DB;
+    const earlier = await remembered(d1, wanted.operation);
+    if (earlier !== undefined)
+        return earlier;
+    const source = sources.find((item) => item.name === wanted.source);
+    const current = source === undefined
+        ? undefined
+        : await cardOf(d1, sources, wanted.source, wanted.id);
+    if (source === undefined || current === undefined) {
+        throw refused(404, 'No such request');
+    }
+    if (current.revision !== wanted.revision)
+        throw refused(409, CHANGED);
+    if (!current.actions.includes(wanted.action)) {
+        throw refused(409, 'That can’t be done to this request now');
+    }
+    const statements = await actionStatements(d1, source, wanted);
+    try {
+        await d1.batch([
+            d1
+                .prepare('INSERT INTO request_operations (id, result) VALUES (?1, ?2)')
+                .bind(wanted.operation, ''),
+            ...statements
+        ]);
+    }
+    catch (error) {
+        const again = await remembered(d1, wanted.operation);
+        if (again !== undefined)
+            return again;
+        throw error;
+    }
+    const after = await cardOf(d1, sources, wanted.source, wanted.id);
+    if (after === undefined || after.revision !== wanted.revision + 1) {
+        await d1
+            .prepare('DELETE FROM request_operations WHERE id = ?1')
+            .bind(wanted.operation)
+            .run();
+        throw refused(409, CHANGED);
+    }
+    await d1
+        .prepare('UPDATE request_operations SET result = ?1 WHERE id = ?2')
+        .bind(JSON.stringify(after), wanted.operation)
+        .run();
+    return after;
+}
+function answer(c, work) {
+    return work().then((reply) => c.json(reply), (error) => {
+        if (error instanceof ServiceRefused) {
+            return c.json({ error: error.message }, error.status);
+        }
+        throw error;
+    });
+}
+export function requestGateway(sources) {
+    return new Hono()
+        .get('/pattern/requests/sync', (c) => answer(c, () => sync(c, sources)))
+        .post('/pattern/requests/act', (c) => answer(c, () => act(c, sources)));
+}

package/dist/server/services.js

@@ -23,7 +23,15 @@ async function inputOf(c, call) {
         ? { ok: true, data: parsed.data }
         : { ok: false, problem: z.prettifyError(parsed.error) };
 }
-const BUILT_IN_PATHS = ['/auth', '/health', '/tables', '/app', '/me', '/schema'];
+const BUILT_IN_PATHS = [
+    '/auth',
+    '/health',
+    '/tables',
+    '/app',
+    '/me',
+    '/schema',
+    '/pattern'
+];
 function builtInPathOf(path) {
     return BUILT_IN_PATHS.find((prefix) => path === prefix || path.startsWith(`${prefix}/`));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trypattern/sdk",
-  "version": "0.1.33",
+  "version": "0.1.34",
   "type": "module",
   "files": [
     "dist",