@trypattern/sdk 0.1.8 → 0.1.10

package/dist/server/createServer.d.ts

@@ -1,11 +1,13 @@
 import { Hono } from 'hono';
 import type { Tables } from '../table.ts';
 import type { ServerBindings, ServerEnv } from './env.ts';
-export declare function createServer<Group extends Tables, Bindings extends ServerBindings = ServerBindings>({ tables, admins, routes }: {
+import type { Pages } from './pages.ts';
+export declare function createServer<Group extends Tables, Bindings extends ServerBindings = ServerBindings>({ tables, admins, routes, pages }: {
     tables: Group;
     admins: readonly string[];
     routes?: Hono<ServerEnv<Bindings>>;
-}): import("hono/hono-base").HonoBase<ServerEnv, (((({
+    pages?: Pages;
+}): import("hono/hono-base").HonoBase<ServerEnv, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<(((({
     "/api/health": {
         $get: {
             input: {};
@@ -172,8 +174,90 @@ export declare function createServer<Group extends Tables, Bindings extends Serv
         };
     };
 }) | import("hono/types").MergeSchemaPath<{
+    "/schema": {
+        $get: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 403;
+        } | {
+            input: {};
+            output: {
+                tables: {
+                    name: string;
+                    schema: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    };
+                    access: {
+                        read: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                        create: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                        update: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                        delete: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                    };
+                    public: string[];
+                    rowCount: number;
+                    isBuiltIn: boolean;
+                }[];
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/tables/users": {
+        $get: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 403;
+        } | {
+            input: {};
+            output: readonly {
+                readonly [x: string]: import("hono/utils/types").JSONValue;
+            }[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        };
+    };
+}, "/api"> | import("hono/types").MergeSchemaPath<{
     "/:table": {
         $get: {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: readonly {
+                readonly [x: string]: import("hono/utils/types").JSONValue;
+            }[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
             input: {
                 param: {
                     table: string;
@@ -190,9 +274,11 @@ export declare function createServer<Group extends Tables, Bindings extends Serv
                     table: string;
                 };
             };
-            output: {}[];
+            output: {
+                error: string;
+            };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 404;
         } | {
             input: {
                 param: {
@@ -203,7 +289,7 @@ export declare function createServer<Group extends Tables, Bindings extends Serv
                 error: string;
             };
             outputFormat: "json";
-            status: 404;
+            status: 400;
         };
     };
 } & {
@@ -399,4 +485,4 @@ export declare function createServer<Group extends Tables, Bindings extends Serv
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/api/tables">, "/api", "/api/me">;
+}, "/api/tables">, "/">, "/", "/">;

package/dist/server/createServer.js

@@ -2,10 +2,15 @@ import { Hono } from 'hono';
 import { csrf } from 'hono/csrf';
 import { adminEmails } from "../access.js";
 import { appTitle } from "../appTitle.js";
+import { media } from "../media.js";
 import { auth, devSignIn } from "./auth.js";
+import { serveDatabase } from "./database.js";
+import { attachPatternViewer, bearerOf } from "./patternViewer.js";
 import { forgetSession, issuePass, needsRecheck, readPass, rememberUser } from "./session.js";
 import { renewSession } from "./sessions.js";
 import { readTitle, writeTitle } from "./settings.js";
+import { serveMedia, uploadMedia } from "./media.js";
+import { matchPage, renderPage, robots, sitemap, wantsHtml } from "./pages.js";
 import { serveTables } from "./tables.js";
 import { findUser } from "./users.js";
 const PUBLIC_PATHS = ['/api/health', '/api/auth/'];
@@ -19,6 +24,9 @@ function knowAdmins(admins) {
     };
 }
 async function attachViewer(c, next) {
+    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 ||
@@ -42,8 +50,9 @@ async function attachViewer(c, next) {
     });
     return next();
 }
-export function createServer({ tables, admins, routes }) {
+export function createServer({ tables, admins, routes, pages }) {
     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())
@@ -76,7 +85,34 @@ export function createServer({ tables, admins, routes }) {
         rememberUser(c, user);
         return c.json({ ...user, isAdmin: viewer?.isAdmin ?? false }, 200);
     })
+        .route('/', serveDatabase(tables))
         .route('/tables', serveTables(tables));
+    if (hasMedia)
+        server.post('/media', uploadMedia);
     const own = routes;
-    return (own === undefined ? server : server.route('/', own)).notFound((c) => c.json({ error: `No route for ${c.req.path}` }, 404));
+    const root = new Hono();
+    if (hasMedia)
+        root.get('/media/*', serveMedia);
+    if (pages !== undefined) {
+        root.get('/sitemap.xml', (c) => sitemap(c, pages));
+        root.get('/robots.txt', robots);
+    }
+    return root
+        .route('/', own === undefined ? server : server.route('/', own))
+        .notFound((c) => {
+        if (c.req.path === '/api' || c.req.path.startsWith('/api/')) {
+            return c.json({ error: `No route for ${c.req.path}` }, 404);
+        }
+        const page = pages === undefined || !wantsHtml(c)
+            ? undefined
+            : matchPage(pages, c.req.path);
+        if (page !== undefined && pages !== undefined) {
+            return renderPage(c, pages, page.route, page.params);
+        }
+        const assets = c.env.ASSETS;
+        if (assets === undefined) {
+            return c.json({ error: `No route for ${c.req.path}` }, 404);
+        }
+        return assets.fetch(c.req.raw);
+    });
 }

package/dist/server/database.d.ts

@@ -0,0 +1,74 @@
+import type { Tables } from '../table.ts';
+import type { ServerEnv } from './env.ts';
+export declare function serveDatabase<Group extends Tables>(tables: Group): import("hono/hono-base").HonoBase<ServerEnv, {
+    "/schema": {
+        $get: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 403;
+        } | {
+            input: {};
+            output: {
+                tables: {
+                    name: string;
+                    schema: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    };
+                    access: {
+                        read: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                        create: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                        update: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                        delete: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                    };
+                    public: string[];
+                    rowCount: number;
+                    isBuiltIn: boolean;
+                }[];
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/tables/users": {
+        $get: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 403;
+        } | {
+            input: {};
+            output: readonly {
+                readonly [x: string]: import("hono/utils/types").JSONValue;
+            }[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        };
+    };
+}, "/", "/tables/users">;

package/dist/server/database.js

@@ -0,0 +1,93 @@
+import { asc, count } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/d1';
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { PAGE_PROBLEM, afterCursor, pageOf, pageReply } from "./keyset.js";
+import { sqlTable } from "./tables.js";
+import { users } from "./users.js";
+const userRow = z.object({
+    id: z.string(),
+    email: z.string(),
+    name: z.string(),
+    avatarUrl: z.string().nullable(),
+    createdAt: z.string()
+});
+const USERS_ACCESS = {
+    read: 'admin',
+    create: 'server',
+    update: 'server',
+    delete: 'server'
+};
+function adminRefusal(c) {
+    const viewer = c.get('viewer');
+    if (viewer === null)
+        return c.json({ error: 'Signed out' }, 401);
+    return viewer.isAdmin ? undefined : c.json({ error: 'forbidden' }, 403);
+}
+function jsonSchemaOf(schema) {
+    return z.toJSONSchema(schema, { unrepresentable: 'any' });
+}
+async function rowCount(c, table) {
+    const counted = await drizzle(c.env.DB)
+        .select({ count: count() })
+        .from(sqlTable(table))
+        .get();
+    return counted?.count ?? 0;
+}
+async function userCount(c) {
+    const counted = await drizzle(c.env.DB)
+        .select({ count: count() })
+        .from(users)
+        .get();
+    return counted?.count ?? 0;
+}
+export function serveDatabase(tables) {
+    const listed = Object.values(tables).filter((table) => table.access.read !== 'server');
+    return new Hono()
+        .get('/schema', async (c) => {
+        const refusal = adminRefusal(c);
+        if (refusal !== undefined)
+            return refusal;
+        const own = await Promise.all(listed.map(async (table) => ({
+            name: table.name,
+            schema: jsonSchemaOf(table.row),
+            access: table.access,
+            public: [...table.public],
+            rowCount: await rowCount(c, table),
+            isBuiltIn: false
+        })));
+        const builtIn = {
+            name: 'users',
+            schema: jsonSchemaOf(userRow),
+            access: USERS_ACCESS,
+            public: [],
+            rowCount: await userCount(c),
+            isBuiltIn: true
+        };
+        return c.json({ tables: [...own, builtIn] });
+    })
+        .get('/tables/users', async (c) => {
+        const refusal = adminRefusal(c);
+        if (refusal !== undefined)
+            return refusal;
+        const page = pageOf(c);
+        if (page === 'invalid') {
+            return c.json({ error: PAGE_PROBLEM }, 400);
+        }
+        const query = drizzle(c.env.DB)
+            .select({
+            id: users.id,
+            email: users.email,
+            name: users.name,
+            avatarUrl: users.avatarUrl,
+            createdAt: users.createdAt
+        })
+            .from(users)
+            .where(afterCursor(users.createdAt, users.id, page))
+            .orderBy(asc(users.createdAt), asc(users.id));
+        const rows = await (page === undefined
+            ? query
+            : query.limit(page.limit + 1));
+        return pageReply(c, rows, page);
+    });
+}

package/dist/server/env.d.ts

@@ -1,10 +1,12 @@
-import type { D1Database } from '@cloudflare/workers-types';
+import type { D1Database, Fetcher, R2Bucket } from '@cloudflare/workers-types';
 import type { Viewer } from '../access.ts';
 export type { Viewer };
 export type ServerBindings = {
     DB: D1Database;
     SESSION_SECRET: string;
     AUTH_SECRET?: string;
+    MEDIA?: R2Bucket;
+    ASSETS?: Fetcher;
 };
 export type ServerEnv<Bindings extends ServerBindings = ServerBindings> = {
     Bindings: Bindings;

package/dist/server/imageHeader.d.ts

@@ -0,0 +1,10 @@
+export type ImageFormat = {
+    type: 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif' | 'image/avif';
+    extension: 'jpg' | 'png' | 'webp' | 'gif' | 'avif';
+};
+export type ImageHeader = ImageFormat & {
+    width: number;
+    height: number;
+};
+export declare function isHeic(bytes: Uint8Array): boolean;
+export declare function readImageHeader(bytes: Uint8Array): ImageHeader | undefined;

package/dist/server/imageHeader.js

@@ -0,0 +1,159 @@
+const SOF_MARKERS = new Set([
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf
+]);
+const ORIENTATION_TAG = 0x0112;
+const ROTATED_ORIENTATIONS = new Set([5, 6, 7, 8]);
+const HEIC_BRANDS = new Set([
+    'heic',
+    'heix',
+    'hevc',
+    'hevx',
+    'heim',
+    'heis',
+    'mif1',
+    'msf1'
+]);
+const AVIF_BRANDS = new Set(['avif', 'avis']);
+function ascii(bytes, start, length) {
+    return String.fromCharCode(...bytes.subarray(start, start + length));
+}
+function brandsOf(bytes) {
+    if (bytes.length < 16 || ascii(bytes, 4, 4) !== 'ftyp')
+        return [];
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const end = Math.min(bytes.length, view.getUint32(0));
+    const brands = [ascii(bytes, 8, 4)];
+    for (let offset = 16; offset + 4 <= end; offset += 4) {
+        brands.push(ascii(bytes, offset, 4));
+    }
+    return brands;
+}
+export function isHeic(bytes) {
+    const brands = brandsOf(bytes);
+    return (!brands.some((brand) => AVIF_BRANDS.has(brand)) &&
+        brands.some((brand) => HEIC_BRANDS.has(brand)));
+}
+function exifOrientation(view, start, end) {
+    if (end - start < 14)
+        return 1;
+    if (view.getUint32(start) !== 0x45786966 || view.getUint16(start + 4) !== 0)
+        return 1;
+    const tiff = start + 6;
+    const little = view.getUint16(tiff) === 0x4949;
+    const ifd = tiff + view.getUint32(tiff + 4, little);
+    if (ifd + 2 > end)
+        return 1;
+    const count = view.getUint16(ifd, little);
+    for (let index = 0; index < count; index += 1) {
+        const entry = ifd + 2 + index * 12;
+        if (entry + 12 > end)
+            return 1;
+        if (view.getUint16(entry, little) === ORIENTATION_TAG) {
+            return view.getUint16(entry + 8, little);
+        }
+    }
+    return 1;
+}
+function jpegSize(view) {
+    let orientation = 1;
+    let offset = 2;
+    while (offset + 4 <= view.byteLength) {
+        if (view.getUint8(offset) !== 0xff)
+            return undefined;
+        const marker = view.getUint8(offset + 1);
+        if (marker === 0xff) {
+            offset += 1;
+            continue;
+        }
+        const length = view.getUint16(offset + 2);
+        if (marker === 0xe1) {
+            orientation = exifOrientation(view, offset + 4, Math.min(view.byteLength, offset + 2 + length));
+        }
+        if (SOF_MARKERS.has(marker) && offset + 9 <= view.byteLength) {
+            const height = view.getUint16(offset + 5);
+            const width = view.getUint16(offset + 7);
+            return ROTATED_ORIENTATIONS.has(orientation)
+                ? { width: height, height: width }
+                : { width, height };
+        }
+        offset += 2 + length;
+    }
+    return undefined;
+}
+function webpSize(bytes, view) {
+    const chunk = ascii(bytes, 12, 4);
+    if (chunk === 'VP8X' && bytes.length >= 30) {
+        const width = 1 + (view.getUint32(24, true) & 0xffffff);
+        const height = 1 + (view.getUint32(27, true) & 0xffffff);
+        return { width, height };
+    }
+    if (chunk === 'VP8 ' && bytes.length >= 30) {
+        return {
+            width: view.getUint16(26, true) & 0x3fff,
+            height: view.getUint16(28, true) & 0x3fff
+        };
+    }
+    if (chunk === 'VP8L' && bytes.length >= 25) {
+        const bits = view.getUint32(21, true);
+        return { width: 1 + (bits & 0x3fff), height: 1 + ((bits >> 14) & 0x3fff) };
+    }
+    return undefined;
+}
+function avifSize(bytes, view) {
+    const limit = Math.min(bytes.length - 16, 65_536);
+    for (let offset = 4; offset < limit; offset += 1) {
+        if (ascii(bytes, offset, 4) === 'ispe') {
+            return {
+                width: view.getUint32(offset + 8),
+                height: view.getUint32(offset + 12)
+            };
+        }
+    }
+    return undefined;
+}
+function sizeOf(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (bytes.length >= 4 && view.getUint16(0) === 0xffd8) {
+        const size = jpegSize(view);
+        return size && { type: 'image/jpeg', extension: 'jpg', ...size };
+    }
+    if (bytes.length >= 24 && ascii(bytes, 1, 3) === 'PNG') {
+        return {
+            type: 'image/png',
+            extension: 'png',
+            width: view.getUint32(16),
+            height: view.getUint32(20)
+        };
+    }
+    if (bytes.length >= 10 && ascii(bytes, 0, 4) === 'GIF8') {
+        return {
+            type: 'image/gif',
+            extension: 'gif',
+            width: view.getUint16(6, true),
+            height: view.getUint16(8, true)
+        };
+    }
+    if (bytes.length >= 16 &&
+        ascii(bytes, 0, 4) === 'RIFF' &&
+        ascii(bytes, 8, 4) === 'WEBP') {
+        const size = webpSize(bytes, view);
+        return size && { type: 'image/webp', extension: 'webp', ...size };
+    }
+    if (brandsOf(bytes).some((brand) => AVIF_BRANDS.has(brand))) {
+        const size = avifSize(bytes, view);
+        return size && { type: 'image/avif', extension: 'avif', ...size };
+    }
+    return undefined;
+}
+export function readImageHeader(bytes) {
+    try {
+        const found = sizeOf(bytes);
+        if (found === undefined || found.width < 1 || found.height < 1) {
+            return undefined;
+        }
+        return found;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/server/index.d.ts

@@ -10,4 +10,9 @@ export { readTitle, seedTitleSql, settings, writeTitle } from './settings.ts';
 export { exchangeReply, exchangeRequest, sendCodeReply, sendCodeRequest, verifiedIdentity, verifyCodeReply, verifyCodeRequest } from './signInWire.ts';
 export type { VerifiedIdentity } from './signInWire.ts';
 export { findUser, users } from './users.ts';
-export type { D1Database } from '@cloudflare/workers-types';
+export { MEDIA_LIMIT_BYTES } from '../media.ts';
+export { localBusiness, product } from './jsonLd.ts';
+export type { JsonLd, LocalBusinessFacts, OpeningHours, PostalAddress, ProductFacts, Weekday } from './jsonLd.ts';
+export { definePages } from './pages.ts';
+export type { PageDefinition, PageHead, PageHero, PageParams, PageRequest, Pages } from './pages.ts';
+export type { D1Database, Fetcher, R2Bucket } from '@cloudflare/workers-types';

package/dist/server/index.js

@@ -7,3 +7,6 @@ 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";
 export { findUser, users } from "./users.js";
+export { MEDIA_LIMIT_BYTES } from "../media.js";
+export { localBusiness, product } from "./jsonLd.js";
+export { definePages } from "./pages.js";

package/dist/server/jsonLd.d.ts

@@ -0,0 +1,45 @@
+export type JsonLd = {
+    readonly '@context': 'https://schema.org';
+    readonly '@type': string;
+} & Readonly<Record<string, unknown>>;
+export type Weekday = 'Monday' | 'Tuesday' | 'Wednesday' | 'Thursday' | 'Friday' | 'Saturday' | 'Sunday';
+export type OpeningHours = {
+    days: Weekday | readonly Weekday[];
+    opens: string;
+    closes: string;
+};
+export type PostalAddress = {
+    street?: string;
+    locality?: string;
+    region?: string;
+    postalCode?: string;
+    country?: string;
+};
+export type LocalBusinessFacts = {
+    name: string;
+    url?: string;
+    type?: string;
+    image?: string | readonly string[];
+    description?: string;
+    telephone?: string;
+    email?: string;
+    address?: PostalAddress;
+    hours?: readonly OpeningHours[];
+    priceRange?: string;
+    sameAs?: readonly string[];
+};
+export type ProductFacts = {
+    name: string;
+    url?: string;
+    image?: string | readonly string[];
+    description?: string;
+    sku?: string;
+    brand?: string;
+    offer?: {
+        price: number;
+        currency: string;
+        availability?: 'InStock' | 'OutOfStock' | 'PreOrder' | 'BackOrder';
+    };
+};
+export declare function localBusiness(facts: LocalBusinessFacts): JsonLd;
+export declare function product(facts: ProductFacts): JsonLd;