@trypattern/sdk 0.1.11 → 0.1.13

package/dist/media.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { Row } from './table.ts';
+import type { Fields, Row, Tables } from './table.ts';
 export declare const media: import("./table.ts").TableOf<"media", {
     readonly columns: {
         readonly key: z.ZodString;
@@ -20,6 +20,16 @@ export declare const media: import("./table.ts").TableOf<"media", {
 }>;
 export type Media = Row<typeof media>;
 export type MediaImage = Pick<Media, 'key' | 'width' | 'height' | 'placeholder' | 'alt'>;
+export type StarterPhoto = {
+    id: string;
+    photo: string;
+    alt: string;
+};
+export type Starter<Group extends Tables> = {
+    [Key in keyof Group as Group[Key]['owned'] extends true ? never : Key]?: Group[Key] extends typeof media ? readonly StarterPhoto[] : readonly ({
+        id: string;
+    } & Fields<Group[Key]>)[];
+};
 export declare const MEDIA_LIMIT_BYTES: number;
 export declare const IMAGE_WIDTHS: readonly [320, 640, 960, 1280, 1920];
 export declare function mediaPath(key: string): string;

package/dist/patternAccess.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 export declare const TABLES_READ = "tables:read";
+export declare const MEDIA_WRITE = "media:write";
 export declare const ASSERTION_SECONDS = 60;
 export declare const NEXT_PAGE_HEADER = "x-pattern-next";
 export declare const assertionKey: z.ZodObject<{
@@ -10,12 +11,20 @@ export declare const assertionKey: z.ZodObject<{
     d: z.ZodString;
 }, z.core.$strip>;
 export type AssertionKey = z.output<typeof assertionKey>;
-export declare function signTablesAssertion(key: AssertionKey, { sub, aud }: {
+declare const assertionScope: z.ZodEnum<{
+    "tables:read": "tables:read";
+    "media:write": "media:write";
+}>;
+export type AssertionScope = z.output<typeof assertionScope>;
+export declare function signAssertion(key: AssertionKey, { sub, aud, scope }: {
     sub: string;
     aud: string;
+    scope: AssertionScope;
 }, now: number): Promise<string>;
-export declare function verifiedTablesAssertion(token: string, { hostname, keys, now }: {
+export declare function verifiedAssertion(token: string, { hostname, keys, now, scope }: {
     hostname: string;
     keys: Readonly<Record<string, string>>;
     now: number;
+    scope: AssertionScope;
 }): Promise<string | undefined>;
+export {};

package/dist/patternAccess.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 export const TABLES_READ = 'tables:read';
+export const MEDIA_WRITE = 'media:write';
 export const ASSERTION_SECONDS = 60;
 export const NEXT_PAGE_HEADER = 'x-pattern-next';
 const CLOCK_SKEW_SECONDS = 30;
@@ -11,6 +12,7 @@ export const assertionKey = z.object({
     x: z.string(),
     d: z.string()
 });
+const assertionScope = z.enum([TABLES_READ, MEDIA_WRITE]);
 const assertionHeader = z.object({
     alg: z.literal('EdDSA'),
     typ: z.literal('JWT'),
@@ -19,7 +21,7 @@ const assertionHeader = z.object({
 const assertionClaims = z.object({
     sub: z.email(),
     aud: z.string(),
-    scope: z.literal(TABLES_READ),
+    scope: assertionScope,
     iat: z.int(),
     exp: z.int()
 });
@@ -53,12 +55,12 @@ function jsonOf(text) {
 function encoded(value) {
     return base64url(encoder.encode(JSON.stringify(value)));
 }
-export async function signTablesAssertion(key, { sub, aud }, now) {
+export async function signAssertion(key, { sub, aud, scope }, now) {
     const privateKey = await crypto.subtle.importKey('jwk', { kty: key.kty, crv: key.crv, x: key.x, d: key.d }, ED25519, false, ['sign']);
     const signed = `${encoded({ alg: 'EdDSA', typ: 'JWT', kid: key.kid })}.${encoded({
         sub,
         aud,
-        scope: TABLES_READ,
+        scope,
         iat: now,
         exp: now + ASSERTION_SECONDS
     })}`;
@@ -80,7 +82,7 @@ async function isSignedBy(publicKey, signed, signature) {
         return false;
     }
 }
-export async function verifiedTablesAssertion(token, { hostname, keys, now }) {
+export async function verifiedAssertion(token, { hostname, keys, now, scope }) {
     const [header, claims, signature, ...rest] = token.split('.');
     if (header === undefined ||
         claims === undefined ||
@@ -102,6 +104,8 @@ export async function verifiedTablesAssertion(token, { hostname, keys, now }) {
     if (!parsed.success)
         return undefined;
     const { sub, aud, iat, exp } = parsed.data;
+    if (parsed.data.scope !== scope)
+        return undefined;
     const isFresh = exp > iat &&
         exp - iat <= ASSERTION_SECONDS &&
         iat <= now + CLOCK_SKEW_SECONDS &&

package/dist/publishWire.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 import { appTitle } from './appTitle.ts';
 export { appTitle };
-export { ASSERTION_SECONDS, NEXT_PAGE_HEADER, TABLES_READ, assertionKey, signTablesAssertion } from './patternAccess.ts';
-export type { AssertionKey } from './patternAccess.ts';
+export { ASSERTION_SECONDS, MEDIA_WRITE, NEXT_PAGE_HEADER, TABLES_READ, 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";
 export declare const UPLOAD_LIMIT_BYTES: number;
@@ -21,7 +21,29 @@ export declare const UPLOAD: {
     readonly sdkVersion: "sdkVersion";
     readonly message: "message";
     readonly runWorkerFirst: "runWorkerFirst";
+    readonly starter: "starter";
 };
+export declare const starterContent: z.ZodObject<{
+    photos: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        alt: z.ZodString;
+    }, z.core.$strip>>;
+    sql: z.ZodString;
+}, z.core.$strip>;
+export type StarterContent = z.output<typeof starterContent>;
+export declare const mediaRow: z.ZodObject<{
+    id: z.ZodString;
+    key: z.ZodString;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    placeholder: z.ZodNullable<z.ZodString>;
+    alt: z.ZodString;
+    type: z.ZodString;
+    bytes: z.ZodNumber;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type MediaRow = z.output<typeof mediaRow>;
 export declare function workerFirstPaths(text: string | undefined): readonly string[];
 export declare const PUBLISH_MESSAGE_LIMIT = 100;
 export declare function publishMessage(text: string): string | null;

package/dist/publishWire.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { appTitle } from "./appTitle.js";
 export { appTitle };
-export { ASSERTION_SECONDS, NEXT_PAGE_HEADER, TABLES_READ, assertionKey, signTablesAssertion } from "./patternAccess.js";
+export { ASSERTION_SECONDS, MEDIA_WRITE, NEXT_PAGE_HEADER, TABLES_READ, assertionKey, signAssertion } from "./patternAccess.js";
 import { call, defineServices } from "./services.js";
 export const DASHBOARD_URL = 'https://onpattern.app';
 export const APPS_DOMAIN = 'onpattern.app';
@@ -92,8 +92,28 @@ export const UPLOAD = {
     compatibilityDate: 'compatibilityDate',
     sdkVersion: 'sdkVersion',
     message: 'message',
-    runWorkerFirst: 'runWorkerFirst'
+    runWorkerFirst: 'runWorkerFirst',
+    starter: 'starter'
 };
+export const starterContent = z.object({
+    photos: z.array(z.object({
+        id: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/),
+        path: z.string().startsWith('starter/photos/'),
+        alt: z.string().trim().min(1)
+    })),
+    sql: z.string()
+});
+export const mediaRow = z.object({
+    id: z.string(),
+    key: z.string(),
+    width: z.number(),
+    height: z.number(),
+    placeholder: z.string().nullable(),
+    alt: z.string(),
+    type: z.string(),
+    bytes: z.number(),
+    createdAt: z.string()
+});
 const WORKER_FIRST_PATH = /^!?\/[\w.~\-/*]{0,100}$/;
 const WORKER_FIRST_LIMIT = 32;
 const ALWAYS_WORKER_FIRST = ['/api/*', '/media/*'];

package/dist/react.d.ts

@@ -5,6 +5,8 @@ export { AppearancePicker } from './components/AppearancePicker.tsx';
 export { Avatar } from './components/Avatar.tsx';
 export { Badge } from './components/Badge.tsx';
 export { Button } from './components/Button.tsx';
+export { Calendar } from './components/Calendar.tsx';
+export type { CalendarDay } from './components/Calendar.tsx';
 export { Card } from './components/Card.tsx';
 export { Checkbox } from './components/Checkbox.tsx';
 export { Choice } from './components/Choice.tsx';
@@ -14,6 +16,7 @@ export { CommandPalette } from './components/CommandPalette.tsx';
 export type { CommandMenuItem } from './components/CommandMenu.tsx';
 export { Content } from './components/Content.tsx';
 export { ContextMenu } from './components/ContextMenu.tsx';
+export { ContinueWithGoogle } from './components/ContinueWithGoogle.tsx';
 export { CopyButton } from './components/CopyButton.tsx';
 export { Dialog } from './components/Dialog.tsx';
 export { Divider } from './components/Divider.tsx';

package/dist/react.js

@@ -5,6 +5,7 @@ export { AppearancePicker } from "./components/AppearancePicker.js";
 export { Avatar } from "./components/Avatar.js";
 export { Badge } from "./components/Badge.js";
 export { Button } from "./components/Button.js";
+export { Calendar } from "./components/Calendar.js";
 export { Card } from "./components/Card.js";
 export { Checkbox } from "./components/Checkbox.js";
 export { Choice } from "./components/Choice.js";
@@ -13,6 +14,7 @@ export { CommandMenu } from "./components/CommandMenu.js";
 export { CommandPalette } from "./components/CommandPalette.js";
 export { Content } from "./components/Content.js";
 export { ContextMenu } from "./components/ContextMenu.js";
+export { ContinueWithGoogle } from "./components/ContinueWithGoogle.js";
 export { CopyButton } from "./components/CopyButton.js";
 export { Dialog } from "./components/Dialog.js";
 export { Divider } from "./components/Divider.js";

package/dist/rules/checkAllFiles.js

@@ -390,6 +390,14 @@ function isExported(node) {
     return (ts.canHaveModifiers(node) &&
         (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
 }
+function definesTables(node, source) {
+    if (ts.isCallExpression(node)) {
+        return node.expression.getText(source) === 'defineTables';
+    }
+    return (ts.isObjectLiteralExpression(node) &&
+        node.properties.some((property) => ts.isSpreadAssignment(property) &&
+            definesTables(property.expression, source)));
+}
 function schemaFindings() {
     if (!existsSync(SCHEMA_FILE))
         return [];
@@ -411,8 +419,7 @@ function schemaFindings() {
             node.declarationList.declarations.some((declaration) => ts.isIdentifier(declaration.name) &&
                 declaration.name.text === 'tables' &&
                 declaration.initializer !== undefined &&
-                ts.isCallExpression(declaration.initializer) &&
-                declaration.initializer.expression.getText(source) === 'defineTables')) {
+                definesTables(declaration.initializer, source))) {
             exportsTables = true;
         }
         if (ts.isCallExpression(node) &&
@@ -697,6 +704,11 @@ function themeScaleFindings() {
     }
     return findings;
 }
+function readsStarterRows(path, text, finding) {
+    return (finding.rule === 'import-from-root' &&
+        relative(ROOT, path) === 'seed.ts' &&
+        /^['"]\.\/starter\/rows\.ts['"]/.test(text.slice(finding.offset)));
+}
 const findingLines = [];
 const violatedRules = new Set();
 let scannedCount = 0;
@@ -707,6 +719,8 @@ for (const path of ownedFiles(ROOT)) {
         continue;
     scannedCount += 1;
     for (const finding of scanner(text)) {
+        if (readsStarterRows(path, text, finding))
+            continue;
         violatedRules.add(finding.rule);
         findingLines.push(`${relative(ROOT, path)}:${lineAndColumn(text, finding.offset)}: pattern(${finding.rule})`);
     }

package/dist/rules/lintPlugin.js

@@ -50,6 +50,7 @@ const PRIMITIVES = new Set([
     'Avatar',
     'Badge',
     'Button',
+    'Calendar',
     'Card',
     'Checkbox',
     'Choice',

package/dist/schema.d.ts

@@ -1,6 +1,8 @@
 export { call, defineServices } from './services.ts';
 export type { CallInput, CallReply, ServiceCall, ServiceMemory, Services } from './services.ts';
 export { media } from './media.ts';
-export type { Media, MediaImage } from './media.ts';
+export { bookingTables } from './bookings.ts';
+export type { BookingDay, BookingRequest, BookingRequestFields, BookingRules, BookingSlot, BookingStatus, BookingWindow } from './bookings.ts';
+export type { Media, MediaImage, Starter, StarterPhoto } from './media.ts';
 export { defineTables } from './table.ts';
 export type { Access, Columns, Fields, Level, PublicRow, Row, Seed, Table, TableDefinition, TableOf, Tables, Value, Writes } from './table.ts';

package/dist/schema.js

@@ -1,3 +1,4 @@
 export { call, defineServices } from "./services.js";
 export { media } from "./media.js";
+export { bookingTables } from "./bookings.js";
 export { defineTables } from "./table.js";

package/dist/server/bookings.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from 'hono';
+import type { BookingRequest } from '../bookings.ts';
+import type { ServerBlock, ServerEnv } from './env.ts';
+export type BookingsOptions = {
+    timezone: 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;

package/dist/server/bookings.js

@@ -0,0 +1,142 @@
+import { FULL, RULES_ID, UNAVAILABLE, bookingBlackout, bookingRequests, bookingRules, bookingServices, bookingTables, daysOf, isValidTimezone, rulesOf, rulesProblem, slotFor, takenKey, windowsOn } from "../bookings.js";
+import { refused } from "../services.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}`);
+}
+function requireAdmin(c) {
+    const viewer = c.get('viewer');
+    if (viewer === null)
+        throw refused(401, 'Signed out');
+    if (!viewer.isAdmin)
+        throw refused(403, 'forbidden');
+}
+async function readRules(d1) {
+    const [row, blackouts] = await Promise.all([
+        readRow(d1, bookingRules, RULES_ID),
+        readRows(d1, bookingTables.bookingBlackouts)
+    ]);
+    const parsedRow = row === undefined ? undefined : bookingRules.row.parse(row);
+    return rulesOf(parsedRow, blackouts
+        .map((blackout) => bookingBlackout.parse(blackout))
+        .toSorted((a, b) => a.date.localeCompare(b.date)));
+}
+async function takenBetween(d1, first, last) {
+    const { results } = await d1
+        .prepare(`SELECT date, "window" AS slot, COUNT(*) AS count FROM booking_requests WHERE date >= ?1 AND date <= ?2 AND ${HOLDING_SQL} GROUP BY date, "window"`)
+        .bind(first, last)
+        .all();
+    return new Map(results.map((row) => [takenKey(row.date, row.slot), Number(row.count)]));
+}
+async function availabilityFor(c, timezone, first, last) {
+    const [rules, taken] = await Promise.all([
+        readRules(c.env.DB),
+        takenBetween(c.env.DB, first, last)
+    ]);
+    return { rules, taken, now: new Date(), timezone };
+}
+async function readRequest(d1, id) {
+    const row = await readRow(d1, bookingRequests, id);
+    return row === undefined ? undefined : bookingRequests.row.parse(row);
+}
+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)) {
+        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)
+        throw refused(409, 'This request just changed');
+    const decided = { ...existing, status };
+    await sendBookingEmail(c, { kind: status, request: decided });
+    return decided;
+}
+function monthRange(month) {
+    return { first: `${month}-01`, last: `${month}-31` };
+}
+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'`);
+    }
+    const routes = serveServices(bookingServices, {
+        bookings: {
+            days: async (c, { month }) => {
+                const { first, last } = monthRange(month);
+                const facts = await availabilityFor(c, timezone, first, last);
+                return [...daysOf(month, facts)];
+            },
+            windows: async (c, { date }) => {
+                const facts = await availabilityFor(c, timezone, date, date);
+                return [...windowsOn(date, facts)];
+            },
+            request: async (c, fields) => {
+                const facts = await availabilityFor(c, timezone, fields.date, fields.date);
+                const slot = slotFor(fields.date, fields.window, facts);
+                if (slot === undefined)
+                    throw refused(400, UNAVAILABLE);
+                if (slot.remaining === 0)
+                    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)
+                    throw refused(409, FULL);
+                const saved = await readRequest(c.env.DB, id);
+                if (saved === undefined)
+                    throw new Error('The request was not saved');
+                await sendBookingEmail(c, {
+                    kind: status === 'accepted' ? 'accepted' : 'requested',
+                    request: saved
+                });
+                return saved;
+            },
+            requests: async (c) => {
+                requireAdmin(c);
+                const rows = await readRows(c.env.DB, bookingRequests);
+                return rows.map((row) => bookingRequests.row.parse(row));
+            },
+            accept: (c, { id }) => decide(c, id, 'accepted'),
+            decline: (c, { id }) => decide(c, id, 'declined'),
+            rules: async (c) => {
+                requireAdmin(c);
+                return readRules(c.env.DB);
+            },
+            saveRules: async (c, rules) => {
+                requireAdmin(c);
+                const problem = rulesProblem(rules);
+                if (problem !== undefined)
+                    throw refused(400, problem);
+                const d1 = c.env.DB;
+                await d1.batch([
+                    d1
+                        .prepare('INSERT INTO booking_rules (id, windows, lead_time_hours, days_ahead, auto_accept) VALUES (?1, ?2, ?3, ?4, ?5) ON CONFLICT (id) DO UPDATE SET windows = excluded.windows, lead_time_hours = excluded.lead_time_hours, days_ahead = excluded.days_ahead, auto_accept = excluded.auto_accept')
+                        .bind(RULES_ID, JSON.stringify(rules.windows), rules.leadTimeHours, rules.daysAhead, rules.autoAccept ? 1 : 0),
+                    d1.prepare('DELETE FROM booking_blackouts'),
+                    ...rules.blackouts.map((blackout) => d1
+                        .prepare('INSERT INTO booking_blackouts (id, date, reason) VALUES (?1, ?2, ?3)')
+                        .bind(`blackout-${blackout.date}`, blackout.date, blackout.reason))
+                ]);
+                return readRules(d1);
+            }
+        }
+    });
+    return {
+        name: 'bookings',
+        tables: bookingTables,
+        openPaths: ['/api/bookings/'],
+        routes
+    };
+}

package/dist/server/createServer.d.ts

@@ -1,12 +1,13 @@
 import { Hono } from 'hono';
 import type { Tables } from '../table.ts';
-import type { ServerBindings, ServerEnv } from './env.ts';
+import type { ServerBindings, ServerBlock, ServerEnv } from './env.ts';
 import type { Pages } from './pages.ts';
-export declare function createServer<Group extends Tables, Bindings extends ServerBindings = ServerBindings>({ tables, admins, routes, pages }: {
+export declare function createServer<Group extends Tables, Bindings extends ServerBindings = ServerBindings>({ tables, admins, routes, pages, blocks }: {
     tables: Group;
     admins: readonly string[];
     routes?: Hono<ServerEnv<Bindings>>;
     pages?: Pages;
+    blocks?: readonly ServerBlock[];
 }): import("hono/hono-base").HonoBase<ServerEnv, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<(((({
     "/api/health": {
         $get: {

package/dist/server/createServer.js

@@ -2,6 +2,7 @@ import { Hono } from 'hono';
 import { csrf } from 'hono/csrf';
 import { adminEmails } from "../access.js";
 import { appTitle } from "../appTitle.js";
+import { blockWiringProblem } from "../blocks.js";
 import { media } from "../media.js";
 import { auth, devSignIn } from "./auth.js";
 import { serveDatabase } from "./database.js";
@@ -23,14 +24,17 @@ function knowAdmins(admins) {
         return next();
     };
 }
-async function attachViewer(c, next) {
+function attachViewer(optionalPaths) {
+    return (c, next) => viewerOf(c, next, [...VIEWER_OPTIONAL_PATHS, ...optionalPaths]);
+}
+async function viewerOf(c, next, optionalPaths) {
     const bearer = bearerOf(c);
     if (bearer !== undefined)
         return attachPatternViewer(c, next, bearer);
     if (PUBLIC_PATHS.some((path) => c.req.path.startsWith(path)))
         return next();
     const isOptional = c.req.path === APP_PATH ||
-        VIEWER_OPTIONAL_PATHS.some((path) => c.req.path.startsWith(path));
+        optionalPaths.some((path) => c.req.path.startsWith(path));
     let pass = await readPass(c);
     if (pass !== undefined && needsRecheck(pass)) {
         const user = await renewSession(c.env.DB, pass.sessionId);
@@ -50,14 +54,17 @@ async function attachViewer(c, next) {
     });
     return next();
 }
-export function createServer({ tables, admins, routes, pages }) {
+export function createServer({ tables, admins, routes, pages, blocks = [] }) {
+    const wiring = blockWiringProblem(tables, blocks, 'server');
+    if (wiring !== undefined)
+        throw new Error(wiring);
     const authRoutes = import.meta.env.DEV ? auth.route('/', devSignIn) : auth;
     const hasMedia = Object.values(tables).some((table) => table === media);
     const server = new Hono()
         .basePath('/api')
         .use(csrf())
         .use(knowAdmins(admins))
-        .use(attachViewer)
+        .use(attachViewer(blocks.flatMap((block) => block.openPaths)))
         .get('/health', (c) => c.json({ ok: true }))
         .route('/auth', authRoutes)
         .get('/app', async (c) => c.json({ title: await readTitle(c.env.DB) }))
@@ -89,6 +96,8 @@ export function createServer({ tables, admins, routes, pages }) {
         .route('/tables', serveTables(tables));
     if (hasMedia)
         server.post('/media', uploadMedia);
+    for (const block of blocks)
+        server.route('/', block.routes);
     const own = routes;
     const root = new Hono();
     if (hasMedia)

package/dist/server/env.d.ts

@@ -1,5 +1,7 @@
 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';
 export type { Viewer };
 export type ServerBindings = {
     DB: D1Database;
@@ -15,3 +17,9 @@ export type ServerEnv<Bindings extends ServerBindings = ServerBindings> = {
         admins: ReadonlySet<string>;
     };
 };
+export type ServerBlock = {
+    readonly name: string;
+    readonly tables: Tables;
+    readonly openPaths: readonly string[];
+    readonly routes: Hono<ServerEnv>;
+};

package/dist/server/index.d.ts

@@ -1,5 +1,7 @@
 export { createServer } from './createServer.ts';
-export type { ServerBindings, ServerEnv, Viewer } from './env.ts';
+export type { ServerBindings, ServerBlock, ServerEnv, Viewer } from './env.ts';
+export { bookings } from './bookings.ts';
+export type { BookingsOptions } from './bookings.ts';
 export { seedSql, serveTables, sqlTable, sqlTables } from './tables.ts';
 export { refused } from '../services.ts';
 export { serveServices } from './services.ts';

package/dist/server/index.js

@@ -1,4 +1,5 @@
 export { createServer } from "./createServer.js";
+export { bookings } from "./bookings.js";
 export { seedSql, serveTables, sqlTable, sqlTables } from "./tables.js";
 export { refused } from "../services.js";
 export { serveServices } from "./services.js";

package/dist/server/media.d.ts

@@ -1,5 +1,18 @@
 import type { Context } from 'hono';
 import type { ServerEnv } from './env.ts';
+export declare const IMMUTABLE = "public, max-age=31536000, immutable";
+export type PhotoFacts = {
+    key: string;
+    type: string;
+    width: number;
+    height: number;
+    bytes: number;
+};
+export type PhotoProblem = {
+    problem: string;
+    status: 413 | 415;
+};
+export declare function photoFacts(buffer: ArrayBuffer): Promise<PhotoFacts | PhotoProblem>;
 export declare function uploadMedia(c: Context<ServerEnv>): Promise<(Response & import("hono").TypedResponse<{
     error: string;
 }, 401, "json">) | (Response & import("hono").TypedResponse<{
@@ -8,9 +21,9 @@ export declare function uploadMedia(c: Context<ServerEnv>): Promise<(Response &
     error: string;
 }, 503, "json">) | (Response & import("hono").TypedResponse<{
     error: string;
-}, 413, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
 }, 400, "json">) | (Response & import("hono").TypedResponse<{
     error: string;
-}, 415, "json">) | (Response & import("hono").TypedResponse<{}, 201, "json">)>;
+}, 413 | 415, "json">) | (Response & import("hono").TypedResponse<{}, 200, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 409, "json">) | (Response & import("hono").TypedResponse<{}, 201, "json">)>;
 export declare function serveMedia(c: Context<ServerEnv>): Promise<Response>;