@trypattern/sdk 0.1.20 → 0.1.22

package/dist/publishWire.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { appTitle } from './appTitle.ts';
 export { appTitle };
-export { ASSERTION_SECONDS, MEDIA_WRITE, NEXT_PAGE_HEADER, TABLES_READ, assertionKey, signAssertion } from './patternAccess.ts';
+export { ASSERTION_SECONDS, MEDIA_WRITE, NEXT_PAGE_HEADER, TABLES_READ, TABLES_WRITE, assertionKey, signAssertion } from './patternAccess.ts';
 export type { AssertionKey, AssertionScope } from './patternAccess.ts';
 export declare const DASHBOARD_URL = "https://onpattern.app";
 export declare const APPS_DOMAIN = "onpattern.app";
@@ -320,6 +320,94 @@ export declare const databaseRows: z.ZodObject<{
     next: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export type DatabaseRows = z.output<typeof databaseRows>;
+export declare const CHANGE_SET_ROWS = 300;
+export declare const dataChange: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"add">;
+    table: z.ZodString;
+    row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"update">;
+    table: z.ZodString;
+    id: z.ZodString;
+    before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"remove">;
+    table: z.ZodString;
+    id: z.ZodString;
+    before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>], "op">;
+export type DataChange = z.output<typeof dataChange>;
+export declare const changeOutcome: z.ZodObject<{
+    status: z.ZodEnum<{
+        failed: "failed";
+        applied: "applied";
+        skipped: "skipped";
+    }>;
+    reason: z.ZodNullable<z.ZodString>;
+    row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ChangeOutcome = z.output<typeof changeOutcome>;
+export declare const changeReply: z.ZodObject<{
+    outcomes: z.ZodArray<z.ZodObject<{
+        status: z.ZodEnum<{
+            failed: "failed";
+            applied: "applied";
+            skipped: "skipped";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const changeSetStatus: z.ZodEnum<{
+    declined: "declined";
+    waiting: "waiting";
+    applied: "applied";
+    expired: "expired";
+    undone: "undone";
+}>;
+export declare const changeSet: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        declined: "declined";
+        waiting: "waiting";
+        applied: "applied";
+        expired: "expired";
+        undone: "undone";
+    }>;
+    title: z.ZodString;
+    asked: z.ZodString;
+    device: z.ZodString;
+    createdAt: z.ZodString;
+    decidedAt: z.ZodNullable<z.ZodString>;
+    undoneAt: z.ZodNullable<z.ZodString>;
+    changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        op: z.ZodLiteral<"add">;
+        table: z.ZodString;
+        row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"update">;
+        table: z.ZodString;
+        id: z.ZodString;
+        before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"remove">;
+        table: z.ZodString;
+        id: z.ZodString;
+        before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>], "op">>;
+    outcomes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        status: z.ZodEnum<{
+            failed: "failed";
+            applied: "applied";
+            skipped: "skipped";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ChangeSet = z.output<typeof changeSet>;
 export declare const publishServices: {
     readonly apps: {
         readonly list: NoInfer<import("./services.ts").ServiceCall<"/apps", {}, z.ZodArray<z.ZodObject<{
@@ -647,6 +735,272 @@ export declare const publishServices: {
             next: z.ZodNullable<z.ZodString>;
         }, z.core.$strip>>>;
     };
+    readonly changes: {
+        readonly list: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/changes", {}, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                declined: "declined";
+                waiting: "waiting";
+                applied: "applied";
+                expired: "expired";
+                undone: "undone";
+            }>;
+            title: z.ZodString;
+            asked: z.ZodString;
+            device: z.ZodString;
+            createdAt: z.ZodString;
+            decidedAt: z.ZodNullable<z.ZodString>;
+            undoneAt: z.ZodNullable<z.ZodString>;
+            changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"add">;
+                table: z.ZodString;
+                row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"remove">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>;
+            outcomes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    applied: "applied";
+                    skipped: "skipped";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+                row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>>;
+        readonly read: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/changes/:id", {}, z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                declined: "declined";
+                waiting: "waiting";
+                applied: "applied";
+                expired: "expired";
+                undone: "undone";
+            }>;
+            title: z.ZodString;
+            asked: z.ZodString;
+            device: z.ZodString;
+            createdAt: z.ZodString;
+            decidedAt: z.ZodNullable<z.ZodString>;
+            undoneAt: z.ZodNullable<z.ZodString>;
+            changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"add">;
+                table: z.ZodString;
+                row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"remove">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>;
+            outcomes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    applied: "applied";
+                    skipped: "skipped";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+                row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        readonly create: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/changes", {
+            asked: z.ZodString;
+            changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"add">;
+                table: z.ZodString;
+                row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"remove">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>;
+        }, z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                declined: "declined";
+                waiting: "waiting";
+                applied: "applied";
+                expired: "expired";
+                undone: "undone";
+            }>;
+            title: z.ZodString;
+            asked: z.ZodString;
+            device: z.ZodString;
+            createdAt: z.ZodString;
+            decidedAt: z.ZodNullable<z.ZodString>;
+            undoneAt: z.ZodNullable<z.ZodString>;
+            changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"add">;
+                table: z.ZodString;
+                row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"remove">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>;
+            outcomes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    applied: "applied";
+                    skipped: "skipped";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+                row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        readonly approve: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/changes/:id/approve", {}, z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                declined: "declined";
+                waiting: "waiting";
+                applied: "applied";
+                expired: "expired";
+                undone: "undone";
+            }>;
+            title: z.ZodString;
+            asked: z.ZodString;
+            device: z.ZodString;
+            createdAt: z.ZodString;
+            decidedAt: z.ZodNullable<z.ZodString>;
+            undoneAt: z.ZodNullable<z.ZodString>;
+            changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"add">;
+                table: z.ZodString;
+                row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"remove">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>;
+            outcomes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    applied: "applied";
+                    skipped: "skipped";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+                row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        readonly decline: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/changes/:id/decline", {}, z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                declined: "declined";
+                waiting: "waiting";
+                applied: "applied";
+                expired: "expired";
+                undone: "undone";
+            }>;
+            title: z.ZodString;
+            asked: z.ZodString;
+            device: z.ZodString;
+            createdAt: z.ZodString;
+            decidedAt: z.ZodNullable<z.ZodString>;
+            undoneAt: z.ZodNullable<z.ZodString>;
+            changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"add">;
+                table: z.ZodString;
+                row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"remove">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>;
+            outcomes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    applied: "applied";
+                    skipped: "skipped";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+                row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        readonly undo: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/changes/:id/undo", {}, z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                declined: "declined";
+                waiting: "waiting";
+                applied: "applied";
+                expired: "expired";
+                undone: "undone";
+            }>;
+            title: z.ZodString;
+            asked: z.ZodString;
+            device: z.ZodString;
+            createdAt: z.ZodString;
+            decidedAt: z.ZodNullable<z.ZodString>;
+            undoneAt: z.ZodNullable<z.ZodString>;
+            changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"add">;
+                table: z.ZodString;
+                row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"remove">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>;
+            outcomes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    applied: "applied";
+                    skipped: "skipped";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+                row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    };
     readonly logins: {
         readonly read: NoInfer<import("./services.ts").ServiceCall<"/cli/logins/:approval", {}, z.ZodObject<{
             code: z.ZodString;

package/dist/publishWire.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { appTitle } from "./appTitle.js";
 export { appTitle };
-export { ASSERTION_SECONDS, MEDIA_WRITE, NEXT_PAGE_HEADER, TABLES_READ, assertionKey, signAssertion } from "./patternAccess.js";
+export { ASSERTION_SECONDS, MEDIA_WRITE, NEXT_PAGE_HEADER, TABLES_READ, TABLES_WRITE, assertionKey, signAssertion } from "./patternAccess.js";
 import { call, defineServices } from "./services.js";
 export const DASHBOARD_URL = 'https://onpattern.app';
 export const APPS_DOMAIN = 'onpattern.app';
@@ -256,6 +256,50 @@ export const databaseRows = z.object({
     rows: z.array(databaseRow),
     next: z.string().nullable()
 });
+export const CHANGE_SET_ROWS = 300;
+const tableName = z.string().regex(/^[a-zA-Z][a-zA-Z0-9]*$/);
+const rowId = z.string().min(1).max(200);
+export const dataChange = z.discriminatedUnion('op', [
+    z.object({ op: z.literal('add'), table: tableName, row: databaseRow }),
+    z.object({
+        op: z.literal('update'),
+        table: tableName,
+        id: rowId,
+        before: databaseRow,
+        after: databaseRow
+    }),
+    z.object({
+        op: z.literal('remove'),
+        table: tableName,
+        id: rowId,
+        before: databaseRow
+    })
+]);
+export const changeOutcome = z.object({
+    status: z.enum(['applied', 'skipped', 'failed']),
+    reason: z.string().nullable(),
+    row: databaseRow.nullable()
+});
+export const changeReply = z.object({ outcomes: z.array(changeOutcome) });
+export const changeSetStatus = z.enum([
+    'waiting',
+    'applied',
+    'declined',
+    'expired',
+    'undone'
+]);
+export const changeSet = z.object({
+    id: z.string(),
+    status: changeSetStatus,
+    title: z.string(),
+    asked: z.string(),
+    device: z.string(),
+    createdAt: z.string(),
+    decidedAt: z.string().nullable(),
+    undoneAt: z.string().nullable(),
+    changes: z.array(dataChange),
+    outcomes: z.array(changeOutcome).nullable()
+});
 export const publishServices = defineServices({
     apps: {
         list: call({ get: '/apps', reply: z.array(appSummary) }),
@@ -332,6 +376,27 @@ export const publishServices = defineServices({
             reply: databaseRows
         })
     },
+    changes: {
+        list: call({ get: '/apps/:name/changes', reply: z.array(changeSet) }),
+        read: call({ get: '/apps/:name/changes/:id', reply: changeSet }),
+        create: call({
+            post: '/apps/:name/changes',
+            input: {
+                asked: z.string().trim().min(1).max(1000),
+                changes: z.array(dataChange).min(1).max(CHANGE_SET_ROWS)
+            },
+            reply: changeSet
+        }),
+        approve: call({
+            post: '/apps/:name/changes/:id/approve',
+            reply: changeSet
+        }),
+        decline: call({
+            post: '/apps/:name/changes/:id/decline',
+            reply: changeSet
+        }),
+        undo: call({ post: '/apps/:name/changes/:id/undo', reply: changeSet })
+    },
     logins: {
         read: call({ get: '/cli/logins/:approval', reply: loginToApprove }),
         approve: call({

package/dist/server/authService.d.ts

@@ -10,6 +10,7 @@ export type AuthService = {
 export type OwnerNote = {
     subject: string;
     text: string;
+    replyTo?: string;
 };
 export declare function authServiceFor(env: ServerBindings): AuthService | undefined;
 export declare function notifyOwner(env: ServerBindings, note: OwnerNote): Promise<boolean>;

package/dist/server/bookings.d.ts

@@ -3,10 +3,11 @@ import type { BookingRequest } from '../bookings.ts';
 import type { ServerBlock, ServerEnv } from './env.ts';
 export type BookingsOptions = {
     timezone: string;
+    managePath?: string;
 };
 export type BookingEmail = {
     kind: 'requested' | 'accepted' | 'declined';
     request: BookingRequest;
 };
 export declare function sendBookingEmail(c: Context<ServerEnv>, email: BookingEmail): Promise<void>;
-export declare function bookings({ timezone }: BookingsOptions): ServerBlock;
+export declare function bookings({ timezone, managePath }: BookingsOptions): ServerBlock;

package/dist/server/bookings.js

@@ -10,9 +10,22 @@ export async function sendBookingEmail(c, email) {
     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}`);
 }
-function ownerNoteOf(request) {
+function clockOf(time) {
+    const [hours = 0, minutes = 0] = time.split(':').map(Number);
+    const hour = hours % 12 === 0 ? 12 : hours % 12;
+    const suffix = hours < 12 ? 'am' : 'pm';
+    return minutes === 0
+        ? `${hour}${suffix}`
+        : `${hour}:${String(minutes).padStart(2, '0')}${suffix}`;
+}
+function whenOf(request, label) {
+    const day = new Date(`${request.date}T12:00:00Z`).toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric', timeZone: 'UTC' });
+    const [start = '', end = ''] = request.window.split('-');
+    return `${day}, ${label} (${clockOf(start)}–${clockOf(end)})`;
+}
+function ownerNoteOf(request, label, manage) {
     const lines = [
-        `${request.name} asked to book ${request.offering} on ${request.date}, ${request.window}.`,
+        `${request.name} asked to book ${request.offering} on ${whenOf(request, label)}.`,
         '',
         `Email: ${request.email}`,
         ...(request.phone === '' ? [] : [`Phone: ${request.phone}`]),
@@ -20,12 +33,14 @@ function ownerNoteOf(request) {
         ...(request.notes === '' ? [] : ['', request.notes]),
         '',
         request.status === 'accepted'
-            ? 'It is booked: your booking rules accept requests on their own.'
-            : 'Accept or decline it on your site.'
+            ? `It is booked: your booking rules accept requests on their own. See it at ${manage}`
+            : `Accept or decline it at ${manage}`,
+        `Reply to this email to write to ${request.name}.`
     ];
     return {
         subject: `New booking request from ${request.name}`,
-        text: lines.join('\n')
+        text: lines.join('\n'),
+        replyTo: request.email
     };
 }
 function requireAdmin(c) {
@@ -84,7 +99,7 @@ async function decide(c, id, status) {
 function monthRange(month) {
     return { first: `${month}-01`, last: `${month}-31` };
 }
-export function bookings({ timezone }) {
+export function bookings({ timezone, managePath = '/' }) {
     if (!isValidTimezone(timezone)) {
         throw new Error(`bookings({ timezone: '${timezone}' }) is not a time zone: use an IANA name such as 'America/Toronto'`);
     }
@@ -116,7 +131,7 @@ export function bookings({ timezone }) {
                 const saved = await readRequest(c.env.DB, id);
                 if (saved === undefined)
                     throw new Error('The request was not saved');
-                await notifyOwner(c.env, ownerNoteOf(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

package/dist/server/changes.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from 'hono';
+import type { Tables } from '../table.ts';
+import type { ServerEnv } from './env.ts';
+export declare function applyChanges<Group extends Tables>(c: Context<ServerEnv>, tables: Group): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 401, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 403, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    outcomes: {
+        status: "failed" | "applied" | "skipped";
+        reason: string | null;
+        row: {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | null;
+    }[];
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;

package/dist/server/changes.js

@@ -0,0 +1,113 @@
+import { eq } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/d1';
+import { z } from 'zod';
+import { dataChange } from "../publishWire.js";
+import { column, readRow, sqlTable } from "./tables.js";
+const changeRequest = z.object({ changes: z.array(dataChange).max(1000) });
+const META_KEYS = new Set(['id', 'createdAt', 'ownerId']);
+function sameValue(left, right) {
+    return JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+}
+function changedSince(current, before, keys) {
+    return keys.some((key) => !sameValue(current[key], before[key]));
+}
+function withoutMeta(row) {
+    return Object.fromEntries(Object.entries(row).filter(([key]) => !META_KEYS.has(key)));
+}
+function failed(reason) {
+    return { status: 'failed', reason, row: null };
+}
+function skipped(reason) {
+    return { status: 'skipped', reason, row: null };
+}
+function problemOf(failure) {
+    for (let error = failure; error instanceof Error; error = error.cause) {
+        if (error.message.includes('UNIQUE constraint failed')) {
+            return 'Another row already has that value';
+        }
+    }
+    return 'The site couldn’t save this row';
+}
+async function applyOne(c, table, change) {
+    const target = sqlTable(table);
+    const db = drizzle(c.env.DB);
+    if (change.op === 'add') {
+        if (table.owned)
+            return failed('Rows in this table belong to their makers');
+        const id = typeof change.row['id'] === 'string' && change.row['id'] !== ''
+            ? change.row['id']
+            : crypto.randomUUID();
+        const parsed = table.incoming.safeParse({ ...withoutMeta(change.row), id });
+        if (!parsed.success)
+            return failed(z.prettifyError(parsed.error));
+        const saved = await db
+            .insert(target)
+            .values(parsed.data)
+            .returning()
+            .get()
+            .catch((failure) => problemOf(failure));
+        if (typeof saved === 'string')
+            return failed(saved);
+        return {
+            status: 'applied',
+            reason: null,
+            row: (await readRow(c.env.DB, table, id)) ?? null
+        };
+    }
+    const current = await readRow(c.env.DB, table, change.id);
+    if (current === undefined)
+        return skipped('It was removed since');
+    if (change.op === 'remove') {
+        if (changedSince(current, change.before, Object.keys(change.before))) {
+            return skipped('It changed since');
+        }
+        await db.delete(target).where(eq(column(target, 'id'), change.id));
+        return { status: 'applied', reason: null, row: current };
+    }
+    const keys = Object.keys(withoutMeta(change.after));
+    if (changedSince(current, change.before, keys)) {
+        return skipped('It changed since');
+    }
+    const parsed = table.incoming.safeParse({
+        ...withoutMeta(current),
+        ...withoutMeta(change.after),
+        id: change.id
+    });
+    if (!parsed.success)
+        return failed(z.prettifyError(parsed.error));
+    const values = Object.fromEntries(keys.map((key) => [key, Reflect.get(parsed.data, key)]));
+    const saved = await db
+        .update(target)
+        .set(values)
+        .where(eq(column(target, 'id'), change.id))
+        .run()
+        .then(() => undefined)
+        .catch((failure) => problemOf(failure));
+    if (saved !== undefined)
+        return failed(saved);
+    return {
+        status: 'applied',
+        reason: null,
+        row: (await readRow(c.env.DB, table, change.id)) ?? null
+    };
+}
+export async function applyChanges(c, tables) {
+    const viewer = c.get('viewer');
+    if (viewer === null)
+        return c.json({ error: 'Signed out' }, 401);
+    if (!viewer.isAdmin)
+        return c.json({ error: 'forbidden' }, 403);
+    const body = changeRequest.safeParse(await c.req.json().catch(() => null));
+    if (!body.success) {
+        return c.json({ error: z.prettifyError(body.error) }, 400);
+    }
+    const known = new Map(Object.values(tables).map((table) => [table.name, table]));
+    const outcomes = [];
+    for (const change of body.data.changes) {
+        const table = known.get(change.table);
+        outcomes.push(table === undefined || table.access.read === 'server'
+            ? failed('No such table')
+            : await applyOne(c, table, change));
+    }
+    return c.json({ outcomes });
+}