@trypattern/sdk 0.1.21 → 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/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 });
+}

package/dist/server/createServer.d.ts

@@ -213,6 +213,44 @@ export declare function createServer<Group extends Tables, Bindings extends Serv
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
+} & {
+    "/changes": {
+        $post: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 403;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {};
+            output: {
+                outcomes: {
+                    status: "failed" | "applied" | "skipped";
+                    reason: string | null;
+                    row: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                }[];
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
 } & {
     "/tables/users": {
         $get: {

package/dist/server/database.d.ts

@@ -39,6 +39,44 @@ export declare function serveDatabase<Group extends Tables>(tables: Group): impo
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
+} & {
+    "/changes": {
+        $post: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 403;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {};
+            output: {
+                outcomes: {
+                    status: "failed" | "applied" | "skipped";
+                    reason: string | null;
+                    row: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                }[];
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
 } & {
     "/tables/users": {
         $get: {