@trypattern/sdk 0.1.8 → 0.1.10

package/dist/server/patternKeys.js

@@ -0,0 +1,3 @@
+export const PATTERN_KEYS = {
+    'pattern-2026-10': 'R0VOZWJtSyBR2jwbN1U3nci1WImH9ZTy27KIw4igaXs'
+};

package/dist/server/patternViewer.d.ts

@@ -0,0 +1,6 @@
+import type { Context, Next } from 'hono';
+import type { ServerEnv } from './env.ts';
+export declare function bearerOf(c: Context<ServerEnv>): string | undefined;
+export declare function attachPatternViewer(c: Context<ServerEnv>, next: Next, token: string): Promise<void | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 401, "json">)>;

package/dist/server/patternViewer.js

@@ -0,0 +1,27 @@
+import { verifiedTablesAssertion } from "../patternAccess.js";
+import { PATTERN_KEYS } from "./patternKeys.js";
+const BEARER = /^bearer\s+/i;
+const SCHEMA_PATH = '/api/schema';
+const TABLES_PATH = '/api/tables/';
+export function bearerOf(c) {
+    const header = c.req.header('authorization') ?? '';
+    return BEARER.test(header) ? header.replace(BEARER, '').trim() : undefined;
+}
+function isReadByPattern(c) {
+    const { path } = c.req;
+    return (c.req.method === 'GET' &&
+        (path === SCHEMA_PATH || path.startsWith(TABLES_PATH)));
+}
+export async function attachPatternViewer(c, next, token) {
+    const email = isReadByPattern(c)
+        ? await verifiedTablesAssertion(token, {
+            hostname: new URL(c.req.url).hostname,
+            keys: PATTERN_KEYS,
+            now: Math.floor(Date.now() / 1000)
+        })
+        : undefined;
+    if (email === undefined)
+        return c.json({ error: 'Signed out' }, 401);
+    c.set('viewer', { userId: `pattern:${email}`, isAdmin: true });
+    return next();
+}

package/dist/server/services.js

@@ -5,7 +5,7 @@ async function inputOf(c, call) {
     const raw = call.method === 'get' ? c.req.query() : await c.req.json().catch(() => ({}));
     return call.input.safeParse(raw);
 }
-const BUILT_IN_PATHS = ['/auth', '/health', '/tables', '/app', '/me'];
+const BUILT_IN_PATHS = ['/auth', '/health', '/tables', '/app', '/me', '/schema'];
 function builtInPathOf(path) {
     return BUILT_IN_PATHS.find((prefix) => path === prefix || path.startsWith(`${prefix}/`));
 }

package/dist/server/tables.d.ts

@@ -1,4 +1,5 @@
 import type { SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
+import type { D1Database } from '@cloudflare/workers-types';
 import type { ServerEnv } from './env.ts';
 import type { Seed, Table, Tables } from '../table.ts';
 type SqlTable = SQLiteTableWithColumns<{
@@ -10,9 +11,22 @@ type SqlTable = SQLiteTableWithColumns<{
 export declare function sqlTable(table: Table): SqlTable;
 export declare function sqlTables<Group extends Tables>(tables: Group): Record<keyof Group, SqlTable>;
 export declare function seedSql<Group extends Tables>(tables: Group, seed: Seed<Group>): string;
+export declare function readRows(d1: D1Database, table: Table): Promise<readonly Record<string, unknown>[]>;
+export declare function readRow(d1: D1Database, table: Table, id: string): Promise<Record<string, unknown> | undefined>;
 export declare function serveTables<Group extends Tables>(tables: Group): import("hono/hono-base").HonoBase<ServerEnv, {
     "/: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;
@@ -29,9 +43,11 @@ export declare function serveTables<Group extends Tables>(tables: Group): import
                     table: string;
                 };
             };
-            output: {}[];
+            output: {
+                error: string;
+            };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 404;
         } | {
             input: {
                 param: {
@@ -42,7 +58,7 @@ export declare function serveTables<Group extends Tables>(tables: Group): import
                 error: string;
             };
             outputFormat: "json";
-            status: 404;
+            status: 400;
         };
     };
 } & {

package/dist/server/tables.js

@@ -1,9 +1,10 @@
-import { asc, eq, sql } from 'drizzle-orm';
+import { and, asc, eq, sql } from 'drizzle-orm';
 import { drizzle } from 'drizzle-orm/d1';
 import { integer, real, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core';
 import { Hono } from 'hono';
 import { z } from 'zod';
 import { changeRefusal, createRefusal, listRefusal, readScope } from "../access.js";
+import { PAGE_PROBLEM, afterCursor, pageOf, pageReply } from "./keyset.js";
 import { ownerIdOf, seededRows, snakeCase } from "../table.js";
 function typesOf(schema) {
     const { type } = z.toJSONSchema(schema);
@@ -98,6 +99,29 @@ export function seedSql(tables, seed) {
     });
     return [...users, ...rowsSql].join('\n');
 }
+function selection(table, target) {
+    return Object.fromEntries([
+        'id',
+        'createdAt',
+        ...(table.owned ? ['ownerId'] : []),
+        ...Object.keys(table.columns)
+    ].map((key) => [key, column(target, key)]));
+}
+export async function readRows(d1, table) {
+    const target = sqlTable(table);
+    return drizzle(d1)
+        .select(selection(table, target))
+        .from(target)
+        .orderBy(asc(column(target, 'createdAt')), asc(column(target, 'id')));
+}
+export async function readRow(d1, table, id) {
+    const target = sqlTable(table);
+    return drizzle(d1)
+        .select(selection(table, target))
+        .from(target)
+        .where(eq(column(target, 'id'), id))
+        .get();
+}
 const REFUSAL_STATUSES = {
     signedOut: { status: 401, error: 'Signed out' },
     forbidden: { status: 403, error: 'forbidden' },
@@ -119,14 +143,6 @@ export function serveTables(tables) {
         table.name,
         { table, target: sqlTable(table) }
     ]));
-    function selection(table, target) {
-        return Object.fromEntries([
-            'id',
-            'createdAt',
-            ...(table.owned ? ['ownerId'] : []),
-            ...Object.keys(table.columns)
-        ].map((key) => [key, column(target, key)]));
-    }
     function publicSelection(table, target) {
         return Object.fromEntries(['id', ...table.public].map((key) => [key, column(target, key)]));
     }
@@ -161,13 +177,21 @@ export function serveTables(tables) {
         if (refusal !== undefined)
             return refuse(c, refusal);
         const scope = readScope(table, viewer);
+        const page = pageOf(c);
+        if (page === 'invalid') {
+            return c.json({ error: PAGE_PROBLEM }, 400);
+        }
         const query = drizzle(c.env.DB)
             .select(selection(table, target))
-            .from(target);
-        const rows = await (typeof scope === 'object'
-            ? query.where(eq(column(target, 'ownerId'), scope.ownerId))
-            : query).orderBy(asc(column(target, 'createdAt')), asc(column(target, 'id')));
-        return c.json(rows);
+            .from(target)
+            .where(and(typeof scope === 'object'
+            ? eq(column(target, 'ownerId'), scope.ownerId)
+            : undefined, afterCursor(column(target, 'createdAt'), column(target, 'id'), page)))
+            .orderBy(asc(column(target, 'createdAt')), asc(column(target, 'id')));
+        const rows = await (page === undefined
+            ? query
+            : query.limit(page.limit + 1));
+        return pageReply(c, rows, page);
     })
         .get('/:table/public', async (c) => {
         const entry = known.get(c.req.param('table'));

package/dist/serviceClients.js

@@ -25,11 +25,9 @@ export function httpServices(services, gate, onSignedOut) {
     return buildClient(services, (group, name, call) => (input = {}) => gate.pass(`${group}.${name}`, async () => {
         const { path, rest } = splitInput(call, input);
         const sent = call.input.parse(rest);
-        const query = call.method === 'get' && Object.keys(sent).length > 0
-            ? `?${new URLSearchParams(Object.entries(sent).map(([key, value]) => [
-                key,
-                String(value)
-            ])).toString()}`
+        const fields = Object.entries(sent).filter(([, value]) => value !== undefined);
+        const query = call.method === 'get' && fields.length > 0
+            ? `?${new URLSearchParams(fields.map(([key, value]) => [key, String(value)])).toString()}`
             : '';
         const response = await fetch(`/api${path}${query}`, {
             method: call.method.toUpperCase(),

package/dist/start.js

@@ -14,6 +14,7 @@ import { AppProvider } from "./hooks/appContext.js";
 import { routeObjects } from "./routes.js";
 import { borders, breakpoints, colors, controls, fontFeatures, fontSizes, fontWeights, fonts, iconSizes, lineHeights, radii, shadows, space, widths } from "./theme/tokens.stylex.js";
 const TEST_SEED = 'patternSeed';
+const INLINE_DATA_ID = 'pattern-data';
 const TEST_ADMINS = 'patternAdmins';
 const TEST_WORLD = 'patternWorld';
 function testSeed() {
@@ -26,6 +27,22 @@ function testAdmins() {
         ? admins.filter((email) => typeof email === 'string')
         : [];
 }
+function readInlineData() {
+    const text = document.getElementById(INLINE_DATA_ID)?.textContent ?? '';
+    if (text === '')
+        return undefined;
+    try {
+        const parsed = JSON.parse(text);
+        return typeof parsed === 'object' &&
+            parsed !== null &&
+            !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function startApp(App, { theme = [], icons = {}, onInteraction } = {}) {
     setAppIcons(icons);
     document.body.className = stylex.props(base.body, theme).className ?? '';
@@ -48,7 +65,8 @@ export function startApp(App, { theme = [], icons = {}, onInteraction } = {}) {
         }),
         cache: Cache.local(),
         gate,
-        clock: inMemory ? manualClock() : realClock()
+        clock: inMemory ? manualClock() : realClock(),
+        inline: inMemory ? undefined : readInlineData()
     });
     if (hot)
         exposeToDevTools(app, gate, hot, world);
@@ -81,12 +99,19 @@ function followAppearance(app) {
 }
 function followTitle(app) {
     const store = app.stores.app;
+    let renderedPath = document.getElementById(INLINE_DATA_ID) === null
+        ? undefined
+        : location.pathname;
     const apply = () => {
+        if (location.pathname === renderedPath)
+            return;
+        renderedPath = undefined;
         const { title } = store.currentState;
         if (title !== '')
             document.title = title;
     };
     store.subscribe(apply);
+    app.router.subscribe(apply);
     apply();
 }
 function exposeToDevTools(app, gate, hot, world) {

package/dist/table.d.ts

@@ -137,6 +137,7 @@ type CheckedTable<Definition> = {
 export declare function defineTables<const Definitions extends Record<string, DraftTable> = Record<never, never>>(definitions: {
     [Key in keyof Definitions]: CheckedTable<Definitions[Key]>;
 }): TablesOf<Definitions>;
+export declare function patternTable<const Name extends string, const Definition extends TableDefinition>(name: Name, definition: Definition): TableOf<Name, Definition>;
 export declare function ownerIdOf(email: string): string;
 export declare function seededRows(seed: Seed<Tables>, name: string): readonly Row<Table>[];
 export declare function snakeCase(name: string): string;

package/dist/table.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 const NAME = /^[a-z][a-zA-Z0-9]*$/;
 const RESERVED = ['id', 'createdAt', 'ownerId'];
 const RESERVED_TABLES = ['users', 'sessions', 'session'];
+const SDK_TABLES = ['media'];
 const SEEDED_AT = Date.UTC(2000, 0, 1);
 function problemIn(name, definition) {
     const { access, columns } = definition;
@@ -28,7 +29,7 @@ function problemIn(name, definition) {
     }
     return undefined;
 }
-function table(name, definition) {
+function table(name, definition, isPatterns = false) {
     const { columns } = definition;
     for (const key of [name, ...Object.keys(columns)]) {
         if (!NAME.test(key)) {
@@ -38,6 +39,9 @@ function table(name, definition) {
     if (RESERVED_TABLES.includes(name)) {
         throw new Error(`A table can't be called "${name}": Pattern keeps its own ${name} for sign-in`);
     }
+    if (!isPatterns && SDK_TABLES.includes(name)) {
+        throw new Error(`A table can't be called "${name}": Pattern has its own ${name} table. Add it with import { ${name} } from '@trypattern/sdk/schema'`);
+    }
     const reserved = RESERVED.find((key) => key in columns);
     if (reserved !== undefined) {
         throw new Error(`Table "${name}" can't have a "${reserved}" column: Pattern adds it`);
@@ -75,6 +79,9 @@ function table(name, definition) {
 export function defineTables(definitions) {
     return Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [name, table(name, definition)]));
 }
+export function patternTable(name, definition) {
+    return table(name, definition, true);
+}
 export function ownerIdOf(email) {
     return `user-${email.toLowerCase()}`;
 }

package/dist/tables.d.ts

@@ -64,10 +64,11 @@ type TableDeps<T extends Table> = {
     publicView?: {
         load: () => Promise<void>;
     };
+    inline?: unknown;
 };
 export declare class TableStore<T extends Table> extends EntityStore<Row<T>> {
     #private;
-    constructor(table: T, { api, cache, viewer, publicView }: TableDeps<T>);
+    constructor(table: T, { api, cache, viewer, publicView, inline }: TableDeps<T>);
     get mayRead(): boolean;
     load(): Promise<void>;
     create(fields: Fields<T>): Promise<WriteOutcome>;

package/dist/tables.js

@@ -172,14 +172,23 @@ export class PublicTableStore extends StoreBase {
         }
     }
 }
+function inlineRows(table, inline) {
+    if (inline === undefined || table.access.read !== 'anyone')
+        return undefined;
+    const parsed = z.array(table.row).safeParse(inline);
+    return parsed.success
+        ? parsed.data
+        : undefined;
+}
 export class TableStore extends EntityStore {
     #table;
     #viewer;
     #publicView;
-    constructor(table, { api, cache, viewer, publicView }) {
+    constructor(table, { api, cache, viewer, publicView, inline }) {
         super({
             api,
             writes: table.writes,
+            initial: inlineRows(table, inline),
             cache: cache.scope(() => `${viewer()?.userId ?? 'anon'}:${table.name}`, z.array(table.row))
         });
         this.#table = table;

package/package.json

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