@trypattern/sdk 0.1.33 → 0.1.34

package/dist/server/bookings.js

@@ -1,15 +1,12 @@
-import { FULL, RULES_ID, UNAVAILABLE, bookingBlackout, bookingRequests, bookingRules, bookingServices, bookingTables, daysOf, isValidTimezone, rulesOf, rulesProblem, slotFor, takenKey, windowsOn } from "../bookings.js";
+import { FULL, RULES_ID, UNAVAILABLE, bookingBlackout, bookingRequests, bookingRules, bookingServices, bookingTables, daysOf, isValidTimezone, rulesOf, rulesProblem, slotFor, takenKey, WEEKDAYS, windowId, windowsOn } from "../bookings.js";
 import { refused } from "../services.js";
+import { storedRows, textOf } from "./inquiries.js";
 import { notifyOwner } from "./authService.js";
+import { afterResponse, drainNotices, receivedStatements, requestsLink, takesRequests, transitionStatements } from "./requests.js";
 import { serveServices } from "./services.js";
 import { readRow, readRows } from "./tables.js";
 const HOLDING_SQL = "status IN ('requested', 'accepted')";
-export async function sendBookingEmail(c, email) {
-    if (!import.meta.env.DEV)
-        return;
-    const to = email.kind === 'requested' ? 'the owner' : email.request.email;
-    console.log(`Booking email (${email.kind}) to ${to} from ${new URL(c.req.url).host}: ${email.request.name}, ${email.request.date} ${email.request.window}`);
-}
+const SOURCE = 'bookings';
 function clockOf(time) {
     const [hours = 0, minutes = 0] = time.split(':').map(Number);
     const hour = hours % 12 === 0 ? 12 : hours % 12;
@@ -23,7 +20,7 @@ function whenOf(request, label) {
     const [start = '', end = ''] = request.window.split('-');
     return `${day}, ${label} (${clockOf(start)}–${clockOf(end)})`;
 }
-function ownerNoteOf(request, label, manage) {
+function ownerNoteOf(request, label, link) {
     const lines = [
         `${request.name} asked to book ${request.offering} on ${whenOf(request, label)}.`,
         '',
@@ -33,8 +30,8 @@ function ownerNoteOf(request, label, manage) {
         ...(request.notes === '' ? [] : ['', request.notes]),
         '',
         request.status === 'accepted'
-            ? `It is booked: your booking rules accept requests on their own. See it at ${manage}`
-            : `Accept or decline it at ${manage}`,
+            ? `It is booked: your booking rules accept requests on their own. See it at ${link}`
+            : `Accept or decline it at ${link}`,
         `Reply to this email to write to ${request.name}.`
     ];
     return {
@@ -78,28 +75,121 @@ async function readRequest(d1, id) {
     const row = await readRow(d1, bookingRequests, id);
     return row === undefined ? undefined : bookingRequests.row.parse(row);
 }
+const DECIDABLE = {
+    accepted: ['requested'],
+    declined: ['requested', 'accepted']
+};
+function decisionStatements(d1, id, status, expected) {
+    const from = DECIDABLE[status].map((item) => `'${item}'`).join(', ');
+    const guard = expected === null
+        ? ''
+        : ' AND (SELECT revision FROM request_states WHERE id = ?3) = ?4';
+    return [
+        d1
+            .prepare(`UPDATE booking_requests SET status = ?1 WHERE id = ?2 AND status IN (${from})${guard}`)
+            .bind(status, id, ...(expected === null ? [] : [`${SOURCE}:${id}`, expected])),
+        ...transitionStatements(d1, {
+            source: SOURCE,
+            requestId: id,
+            event: status,
+            state: 'done',
+            expected
+        })
+    ];
+}
 async function decide(c, id, status) {
     requireAdmin(c);
-    const from = status === 'accepted' ? ['requested'] : ['requested', 'accepted'];
     const existing = await readRequest(c.env.DB, id);
     if (existing === undefined)
         throw refused(404, 'No such request');
-    if (!from.includes(existing.status)) {
+    if (!DECIDABLE[status].includes(existing.status)) {
         throw refused(409, `This request is already ${existing.status}`);
     }
-    const { meta } = await c.env.DB.prepare(`UPDATE booking_requests SET status = ?1 WHERE id = ?2 AND status IN (${from.map((item) => `'${item}'`).join(', ')})`)
-        .bind(status, id)
-        .run();
-    if (meta.changes === 0)
+    const statements = decisionStatements(c.env.DB, id, status, null);
+    const [result] = await c.env.DB.batch((await takesRequests(c.env.DB)) ? statements : statements.slice(0, 1));
+    if (result?.meta.changes === 0) {
         throw refused(409, 'This request just changed');
-    const decided = { ...existing, status };
-    await sendBookingEmail(c, { kind: status, request: decided });
-    return decided;
+    }
+    return { ...existing, status };
+}
+function longDay(date) {
+    return new Date(`${date}T12:00:00Z`).toLocaleDateString('en-GB', {
+        weekday: 'long',
+        day: 'numeric',
+        month: 'long',
+        timeZone: 'UTC'
+    });
+}
+function rangeOf(window) {
+    const [start = '', end = ''] = window.split('-');
+    return `${clockOf(start)}–${clockOf(end)}`;
 }
+function windowLabel(rules, date, window) {
+    const weekday = new Date(`${date}T12:00:00Z`).getUTCDay();
+    const rule = rules.windows.find((item) => item.weekday === WEEKDAYS[weekday] && windowId(item) === window);
+    return rule === undefined
+        ? rangeOf(window)
+        : `${rule.label}, ${rangeOf(window)}`;
+}
+function bookingContent(request, rules) {
+    const [head = request.offering, ...rest] = request.offering.split(', ');
+    const time = windowLabel(rules, request.date, request.window);
+    const isRequested = request.status === 'requested';
+    return {
+        kind: 'booking',
+        title: 'Booking request',
+        label: head,
+        summary: rest.join(', '),
+        name: request.name,
+        email: request.email,
+        when: request.date,
+        whenDetail: time,
+        fields: [
+            { label: 'Booking', value: request.offering },
+            { label: 'Day', value: longDay(request.date) },
+            { label: 'Time', value: time },
+            ...(request.address === ''
+                ? []
+                : [{ label: 'Address', value: request.address }])
+        ],
+        contact: [
+            { label: 'Email', value: request.email },
+            ...(request.phone === ''
+                ? []
+                : [{ label: 'Phone', value: request.phone }])
+        ],
+        message: request.notes,
+        status: request.status,
+        needsAnswer: isRequested,
+        actions: isRequested ? ['accept', 'decline'].slice() : [],
+        receivedAt: request.createdAt
+    };
+}
+const bookingSource = {
+    name: SOURCE,
+    table: 'booking_requests',
+    contents: async (d1, progress) => {
+        const [rules, rows] = await Promise.all([
+            readRules(d1),
+            storedRows(d1, bookingRequests, [...progress.keys()])
+        ]);
+        return new Map([...rows].flatMap(([id, row]) => {
+            const request = bookingRequests.row.safeParse({
+                ...row,
+                id: textOf(row['id'])
+            });
+            return request.success
+                ? [[id, bookingContent(request.data, rules)]]
+                : [];
+        }));
+    },
+    decide: async (d1, id, action, expected) => decisionStatements(d1, id, action === 'accept' ? 'accepted' : 'declined', expected),
+    backfill: (d1) => d1.prepare(`INSERT INTO request_states (id, source, request_id, state, revision, sequence, updated_at) SELECT '${SOURCE}:' || id, '${SOURCE}', id, CASE status WHEN 'requested' THEN 'open' ELSE 'done' END, 1, (SELECT COALESCE(MAX(sequence), 0) FROM request_states) + ROW_NUMBER() OVER (ORDER BY created_at, id), created_at FROM booking_requests WHERE '${SOURCE}:' || id NOT IN (SELECT id FROM request_states)`)
+};
 function monthRange(month) {
     return { first: `${month}-01`, last: `${month}-31` };
 }
-export function bookings({ timezone, managePath = '/' }) {
+export function bookings({ timezone }) {
     if (!isValidTimezone(timezone)) {
         throw new Error(`bookings({ timezone: '${timezone}' }) is not a time zone: use an IANA name such as 'America/Toronto'`);
     }
@@ -123,19 +213,46 @@ export function bookings({ timezone, managePath = '/' }) {
                     throw refused(409, FULL);
                 const id = crypto.randomUUID();
                 const status = facts.rules.autoAccept ? 'accepted' : 'requested';
-                const { meta } = await c.env.DB.prepare(`INSERT INTO booking_requests (id, offering, date, "window", name, email, phone, address, notes, status) SELECT ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10 WHERE (SELECT COUNT(*) FROM booking_requests WHERE date = ?3 AND "window" = ?4 AND ${HOLDING_SQL}) < ?11`)
-                    .bind(id, fields.offering, fields.date, fields.window, fields.name, fields.email, fields.phone ?? '', fields.address ?? '', fields.notes ?? '', status, slot.capacity)
-                    .run();
-                if (meta.changes === 0)
+                const d1 = c.env.DB;
+                const shown = {
+                    ...fields,
+                    id,
+                    createdAt: new Date().toISOString(),
+                    phone: fields.phone ?? '',
+                    address: fields.address ?? '',
+                    notes: fields.notes ?? '',
+                    status
+                };
+                const tracked = await takesRequests(d1);
+                const notice = ownerNoteOf(shown, slot.label, requestsLink(c.env));
+                const [inserted] = await d1.batch([
+                    d1
+                        .prepare(`INSERT INTO booking_requests (id, offering, date, "window", name, email, phone, address, notes, status) SELECT ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10 WHERE (SELECT COUNT(*) FROM booking_requests WHERE date = ?3 AND "window" = ?4 AND ${HOLDING_SQL}) < ?11`)
+                        .bind(id, shown.offering, shown.date, shown.window, shown.name, shown.email, shown.phone, shown.address, shown.notes, status, slot.capacity),
+                    ...(tracked
+                        ? receivedStatements(d1, {
+                            source: SOURCE,
+                            table: 'booking_requests',
+                            requestId: id,
+                            notice
+                        })
+                        : []),
+                    ...(tracked && status === 'accepted'
+                        ? transitionStatements(d1, {
+                            source: SOURCE,
+                            requestId: id,
+                            event: 'accepted',
+                            state: 'done',
+                            expected: null
+                        })
+                        : [])
+                ]);
+                if (inserted?.meta.changes === 0)
                     throw refused(409, FULL);
-                const saved = await readRequest(c.env.DB, id);
+                const saved = await readRequest(d1, id);
                 if (saved === undefined)
                     throw new Error('The request was not saved');
-                await notifyOwner(c.env, ownerNoteOf(saved, slot.label, new URL(managePath, c.req.url).href));
-                await sendBookingEmail(c, {
-                    kind: status === 'accepted' ? 'accepted' : 'requested',
-                    request: saved
-                });
+                await afterResponse(c, tracked ? drainNotices(c.env) : notifyOwner(c.env, notice));
                 return saved;
             },
             requests: async (c) => {
@@ -172,6 +289,7 @@ export function bookings({ timezone, managePath = '/' }) {
         name: 'bookings',
         tables: bookingTables,
         openPaths: ['/api/bookings/'],
-        routes
+        routes,
+        requests: [bookingSource]
     };
 }

package/dist/server/createServer.js

@@ -7,6 +7,7 @@ import { media } from "../media.js";
 import { auth, devSignIn } from "./auth.js";
 import { serveDatabase } from "./database.js";
 import { attachPatternViewer, bearerOf } from "./patternViewer.js";
+import { requestGateway } from "./requests.js";
 import { forgetSession, issuePass, needsRecheck, readPass, rememberUser } from "./session.js";
 import { renewSession } from "./sessions.js";
 import { readTitle, writeTitle } from "./settings.js";
@@ -97,6 +98,9 @@ export function createServer({ tables, admins, routes, pages, blocks = [] }) {
         .route('/tables', serveTables(tables));
     if (hasMedia)
         server.post('/media', uploadMedia);
+    const sources = blocks.flatMap((block) => block.requests ?? []);
+    if (sources.length > 0)
+        server.route('/', requestGateway(sources));
     for (const block of blocks)
         server.route('/', block.routes);
     const own = routes;

package/dist/server/env.d.ts

@@ -2,12 +2,14 @@ import type { D1Database, Fetcher, R2Bucket } from '@cloudflare/workers-types';
 import type { Hono } from 'hono';
 import type { Viewer } from '../access.ts';
 import type { Tables } from '../table.ts';
+import type { RequestSource } from './requests.ts';
 export type { Viewer };
 export type ServerBindings = {
     DB: D1Database;
     SESSION_SECRET: string;
     AUTH_SECRET?: string;
     OWNER_EMAIL?: string;
+    APP_NAME?: string;
     MEDIA?: R2Bucket;
     ASSETS?: Fetcher;
 };
@@ -23,4 +25,5 @@ export type ServerBlock = {
     readonly tables: Tables;
     readonly openPaths: readonly string[];
     readonly routes: Hono<ServerEnv>;
+    readonly requests?: readonly RequestSource[];
 };

package/dist/server/index.d.ts

@@ -3,6 +3,7 @@ export type { ServerBindings, ServerBlock, ServerEnv, Viewer } from './env.ts';
 export { notifyOwner } from './authService.ts';
 export type { OwnerNote } from './authService.ts';
 export { bookings } from './bookings.ts';
+export { inquiries } from './inquiries.ts';
 export type { BookingsOptions } from './bookings.ts';
 export { seedSql, serveTables, sqlTable, sqlTables } from './tables.ts';
 export { refused } from '../services.ts';

package/dist/server/index.js

@@ -1,6 +1,7 @@
 export { createServer } from "./createServer.js";
 export { notifyOwner } from "./authService.js";
 export { bookings } from "./bookings.js";
+export { inquiries } from "./inquiries.js";
 export { seedSql, serveTables, sqlTable, sqlTables } from "./tables.js";
 export { refused } from "../services.js";
 export { serveServices } from "./services.js";

package/dist/server/inquiries.d.ts

@@ -0,0 +1,9 @@
+import type { D1Database } from '@cloudflare/workers-types';
+import type { Inquiry } from '../requests.ts';
+import type { Table } from '../table.ts';
+import type { ServerBlock } from './env.ts';
+type Stored = Readonly<Record<string, unknown>>;
+export declare function textOf(value: unknown): string;
+export declare function storedRows(d1: D1Database, table: Table, ids: readonly string[]): Promise<ReadonlyMap<string, Stored>>;
+export declare function inquiries(sources: readonly Inquiry[]): ServerBlock;
+export {};

package/dist/server/inquiries.js

@@ -0,0 +1,150 @@
+import { drizzle } from 'drizzle-orm/d1';
+import { z } from 'zod';
+import { inquiryServices, requestTables } from "../requests.js";
+import { refused } from "../services.js";
+import { snakeCase } from "../table.js";
+import { afterResponse, drainNotices, receivedStatements, requestsLink } from "./requests.js";
+import { serveServices } from "./services.js";
+import { sqlTable } from "./tables.js";
+export function textOf(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string')
+        return value.trim();
+    return typeof value === 'number' || typeof value === 'boolean'
+        ? String(value)
+        : '';
+}
+export async function storedRows(d1, table, ids) {
+    if (ids.length === 0)
+        return new Map();
+    const { results } = await d1
+        .prepare(`SELECT * FROM ${snakeCase(table.name)} WHERE id IN (SELECT value FROM json_each(?1))`)
+        .bind(JSON.stringify(ids))
+        .all();
+    const keys = ['id', 'createdAt', ...Object.keys(table.columns)];
+    return new Map(results.map((row) => [
+        textOf(row['id']),
+        Object.fromEntries(keys.map((key) => [key, row[snakeCase(key)]]))
+    ]));
+}
+function fieldsOf(inquiry, row) {
+    return [
+        ...inquiry.fields.flatMap(({ key, label }) => {
+            const value = textOf(row[key]);
+            return value === '' ? [] : [{ label, value }];
+        }),
+        { label: 'Email', value: textOf(row[inquiry.email]) }
+    ];
+}
+function noticeOf(inquiry, row, link) {
+    const name = textOf(row[inquiry.name]);
+    const message = inquiry.message === null ? '' : textOf(row[inquiry.message]);
+    const noun = inquiry.title.toLowerCase();
+    return {
+        subject: `New ${noun} from ${name}`,
+        text: [
+            `${name} sent a ${noun} from your site.`,
+            '',
+            ...fieldsOf(inquiry, row).map(({ label, value }) => `${label}: ${value}`),
+            ...(message === '' ? [] : ['', message]),
+            '',
+            `Answer it at ${link}`,
+            `Or reply to this email to write to ${name}.`
+        ].join('\n'),
+        replyTo: textOf(row[inquiry.email])
+    };
+}
+function contentOf(inquiry, row, progress) {
+    const isOpen = progress.state === 'open';
+    const message = inquiry.message === null ? '' : textOf(row[inquiry.message]);
+    const brief = inquiry.summary === null ? message : textOf(row[inquiry.summary]);
+    const when = inquiry.when === null ? '' : textOf(row[inquiry.when.field]);
+    return {
+        kind: 'inquiry',
+        title: inquiry.title,
+        label: inquiry.title,
+        summary: brief === '' ? inquiry.form : `${inquiry.form} · ${brief}`,
+        name: textOf(row[inquiry.name]),
+        email: textOf(row[inquiry.email]),
+        when: when === '' ? null : when,
+        whenDetail: inquiry.when === null ? null : inquiry.when.detail,
+        fields: fieldsOf(inquiry, row),
+        contact: [],
+        message,
+        status: !isOpen
+            ? 'done'
+            : progress.replied
+                ? 'replied'
+                : 'open',
+        needsAnswer: isOpen,
+        actions: isOpen ? ['reply', 'done'].slice() : [],
+        receivedAt: textOf(row['createdAt'])
+    };
+}
+function sourceOf(inquiry) {
+    return {
+        name: inquiry.source,
+        table: snakeCase(inquiry.table.name),
+        contents: async (d1, progress) => {
+            const rows = await storedRows(d1, inquiry.table, [...progress.keys()]);
+            return new Map([...progress].flatMap(([id, step]) => {
+                const row = rows.get(id);
+                return row === undefined
+                    ? []
+                    : [[id, contentOf(inquiry, row, step)]];
+            }));
+        }
+    };
+}
+function checked(sources) {
+    const names = new Set();
+    for (const inquiry of sources) {
+        if (names.has(inquiry.source)) {
+            throw new Error(`Two inquiries are called '${inquiry.source}': give each its own source name`);
+        }
+        names.add(inquiry.source);
+    }
+    return sources;
+}
+export function inquiries(sources) {
+    const known = checked(sources);
+    const routes = serveServices(inquiryServices, {
+        inquiries: {
+            send: async (c, { source, fields }) => {
+                const inquiry = known.find((item) => item.source === source);
+                if (inquiry === undefined)
+                    throw refused(404, 'No such form');
+                const parsed = inquiry.table.fields.safeParse(fields);
+                if (!parsed.success) {
+                    throw refused(400, z.prettifyError(parsed.error));
+                }
+                const id = crypto.randomUUID();
+                const row = { ...parsed.data, id };
+                const d1 = c.env.DB;
+                const insert = drizzle(d1)
+                    .insert(sqlTable(inquiry.table))
+                    .values(row)
+                    .toSQL();
+                await d1.batch([
+                    d1.prepare(insert.sql).bind(...insert.params),
+                    ...receivedStatements(d1, {
+                        source: inquiry.source,
+                        table: snakeCase(inquiry.table.name),
+                        requestId: id,
+                        notice: noticeOf(inquiry, row, requestsLink(c.env))
+                    })
+                ]);
+                await afterResponse(c, drainNotices(c.env));
+                return { id };
+            }
+        }
+    });
+    return {
+        name: 'inquiries',
+        tables: requestTables,
+        openPaths: ['/api/requests/'],
+        routes,
+        requests: known.map(sourceOf)
+    };
+}

package/dist/server/patternViewer.js

@@ -1,4 +1,5 @@
-import { MEDIA_WRITE, TABLES_READ, TABLES_WRITE, verifiedAssertion } from "../patternAccess.js";
+import { MEDIA_WRITE, REQUESTS_ACT, REQUESTS_READ, TABLES_READ, TABLES_WRITE, verifiedAssertion } from "../patternAccess.js";
+import { REQUESTS_PATH } from "../requests.js";
 import { PATTERN_KEYS } from "./patternKeys.js";
 const BEARER = /^bearer\s+/i;
 const SCHEMA_PATH = '/api/schema';
@@ -17,6 +18,11 @@ function scopeOf(c) {
     }
     if (method === 'POST' && path === CHANGES_PATH)
         return TABLES_WRITE;
+    if (method === 'GET' && path === `${REQUESTS_PATH}/sync`) {
+        return REQUESTS_READ;
+    }
+    if (method === 'POST' && path === `${REQUESTS_PATH}/act`)
+        return REQUESTS_ACT;
     return method === 'POST' && path === MEDIA_PATH ? MEDIA_WRITE : undefined;
 }
 export async function attachPatternViewer(c, next, token) {

package/dist/server/requests.d.ts

@@ -0,0 +1,76 @@
+import type { D1Database, D1PreparedStatement } from '@cloudflare/workers-types';
+import type { Context } from 'hono';
+import type { RequestCard } from '../requests.ts';
+import type { ServerBindings, ServerEnv } from './env.ts';
+export type RequestContent = Omit<RequestCard, 'revision' | 'history' | 'notice' | 'source' | 'id' | 'receivedAt'>;
+export type RequestProgress = {
+    state: 'open' | 'done';
+    replied: boolean;
+};
+export type RequestSource = {
+    readonly name: string;
+    readonly table: string;
+    readonly contents: (d1: D1Database, progress: ReadonlyMap<string, RequestProgress>) => Promise<ReadonlyMap<string, RequestContent & {
+        receivedAt: string;
+    }>>;
+    readonly decide?: (d1: D1Database, id: string, action: 'accept' | 'decline', expected: number) => Promise<readonly D1PreparedStatement[]>;
+    readonly backfill?: (d1: D1Database) => D1PreparedStatement;
+};
+export type OwnerNotice = {
+    subject: string;
+    text: string;
+    replyTo: string;
+};
+export declare function takesRequests(d1: D1Database): Promise<boolean>;
+export declare const NEXT_SEQUENCE = "(SELECT COALESCE(MAX(sequence), 0) + 1 FROM request_states)";
+export declare function requestsLink(env: ServerBindings): string;
+export declare function receivedStatements(d1: D1Database, { source, table, requestId, notice }: {
+    source: string;
+    table: string;
+    requestId: string;
+    notice: OwnerNotice;
+}): D1PreparedStatement[];
+export declare function transitionStatements(d1: D1Database, { source, requestId, event, state, expected }: {
+    source: string;
+    requestId: string;
+    event: 'accepted' | 'declined' | 'replied' | 'done';
+    state: 'open' | 'done';
+    expected: number | null;
+}): D1PreparedStatement[];
+export declare function drainNotices(env: ServerBindings, { force }?: {
+    force?: boolean;
+}): Promise<void>;
+export declare function afterResponse(c: Context<ServerEnv>, work: Promise<unknown>): Promise<void>;
+export declare function requestGateway(sources: readonly RequestSource[]): import("hono/hono-base").HonoBase<ServerEnv, {
+    "/pattern/requests/sync": {
+        $get: {
+            input: {};
+            output: never;
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        };
+    };
+} & {
+    "/pattern/requests/act": {
+        $post: {
+            input: {};
+            output: never;
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        };
+    };
+}, "/", "/pattern/requests/act">;