@trypattern/sdk 0.1.21 → 0.1.23

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: {

package/dist/server/database.js

@@ -2,6 +2,7 @@ import { asc, count } from 'drizzle-orm';
 import { drizzle } from 'drizzle-orm/d1';
 import { Hono } from 'hono';
 import { z } from 'zod';
+import { applyChanges } from "./changes.js";
 import { PAGE_PROBLEM, afterCursor, pageOf, pageReply } from "./keyset.js";
 import { sqlTable } from "./tables.js";
 import { users } from "./users.js";
@@ -66,6 +67,7 @@ export function serveDatabase(tables) {
         };
         return c.json({ tables: [...own, builtIn] });
     })
+        .post('/changes', (c) => applyChanges(c, tables))
         .get('/tables/users', async (c) => {
         const refusal = adminRefusal(c);
         if (refusal !== undefined)

package/dist/server/index.d.ts

@@ -8,7 +8,7 @@ export { seedSql, serveTables, sqlTable, sqlTables } from './tables.ts';
 export { refused } from '../services.ts';
 export { serveServices } from './services.ts';
 export type { ServiceHandlers } from './services.ts';
-export { sessionCookieFor } from './session.ts';
+export { sessionCookieFor, sessionIdOf } from './session.ts';
 export { deleteSession, sessions } from './sessions.ts';
 export { readTitle, seedTitleSql, settings, writeTitle } from './settings.ts';
 export { exchangeReply, exchangeRequest, sendCodeReply, sendCodeRequest, verifiedIdentity, verifyCodeReply, verifyCodeRequest } from './signInWire.ts';

package/dist/server/index.js

@@ -4,7 +4,7 @@ export { bookings } from "./bookings.js";
 export { seedSql, serveTables, sqlTable, sqlTables } from "./tables.js";
 export { refused } from "../services.js";
 export { serveServices } from "./services.js";
-export { sessionCookieFor } from "./session.js";
+export { sessionCookieFor, sessionIdOf } from "./session.js";
 export { deleteSession, sessions } from "./sessions.js";
 export { readTitle, seedTitleSql, settings, writeTitle } from "./settings.js";
 export { exchangeReply, exchangeRequest, sendCodeReply, sendCodeRequest, verifiedIdentity, verifyCodeReply, verifyCodeRequest } from "./signInWire.js";

package/dist/server/patternViewer.js

@@ -1,9 +1,10 @@
-import { MEDIA_WRITE, TABLES_READ, verifiedAssertion } from "../patternAccess.js";
+import { MEDIA_WRITE, TABLES_READ, TABLES_WRITE, verifiedAssertion } from "../patternAccess.js";
 import { PATTERN_KEYS } from "./patternKeys.js";
 const BEARER = /^bearer\s+/i;
 const SCHEMA_PATH = '/api/schema';
 const TABLES_PATH = '/api/tables/';
 const MEDIA_PATH = '/api/media';
+const CHANGES_PATH = '/api/changes';
 export function bearerOf(c) {
     const header = c.req.header('authorization') ?? '';
     return BEARER.test(header) ? header.replace(BEARER, '').trim() : undefined;
@@ -14,6 +15,8 @@ function scopeOf(c) {
         (path === SCHEMA_PATH || path.startsWith(TABLES_PATH))) {
         return TABLES_READ;
     }
+    if (method === 'POST' && path === CHANGES_PATH)
+        return TABLES_WRITE;
     return method === 'POST' && path === MEDIA_PATH ? MEDIA_WRITE : undefined;
 }
 export async function attachPatternViewer(c, next, token) {

package/dist/server/session.d.ts

@@ -27,6 +27,7 @@ export declare function readPass(c: Context<ServerEnv>): Promise<{
     email: string;
     recheckAt: number;
 } | undefined>;
+export declare function sessionIdOf<Env extends ServerEnv>(c: Context<Env>): Promise<string | undefined>;
 export declare const needsRecheck: (pass: Pass) => boolean;
 export declare function forgetSession(c: Context<ServerEnv>): void;
 export {};

package/dist/server/session.js

@@ -58,6 +58,9 @@ export async function readPass(c) {
         return undefined;
     }
 }
+export async function sessionIdOf(c) {
+    return (await readPass(c))?.sessionId;
+}
 export const needsRecheck = (pass) => pass.recheckAt <= nowInSeconds();
 export function forgetSession(c) {
     deleteCookie(c, SESSION_COOKIE, { path: '/', secure: true });

package/package.json

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