@trypattern/sdk 0.0.0-stage → 0.1.1

package/dist/server/createServer.d.ts

@@ -0,0 +1,402 @@
+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 }: {
+    tables: Group;
+    admins: readonly string[];
+    routes?: Hono<ServerEnv<Bindings>>;
+}): import("hono/hono-base").HonoBase<ServerEnv, (((({
+    "/api/health": {
+        $get: {
+            input: {};
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} | import("hono/types").MergeSchemaPath<{
+    "/google": {
+        $get: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 503;
+        } | {
+            input: {};
+            output: undefined;
+            outputFormat: "redirect";
+            status: 302;
+        };
+    };
+} & {
+    "/finish": {
+        $get: {
+            input: {};
+            output: undefined;
+            outputFormat: "redirect";
+            status: 302;
+        };
+    };
+} & {
+    "/email": {
+        $post: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 503;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 429;
+        } | {
+            input: {};
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/email/verify": {
+        $post: {
+            input: {};
+            output: {
+                isAdmin: boolean;
+                id: string;
+                name: string;
+                email: string;
+                avatarUrl: string | null;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        };
+    };
+} & {
+    "/sign-out": {
+        $post: {
+            input: {};
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/api/auth">) & {
+    "/api/app": {
+        $get: {
+            input: {};
+            output: {
+                title: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}) & {
+    "/api/app": {
+        $put: {
+            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: {
+                title: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}) & {
+    "/api/me": {
+        $get: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                isAdmin: boolean;
+                id: string;
+                name: string;
+                email: string;
+                avatarUrl: string | null;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}) | import("hono/types").MergeSchemaPath<{
+    "/:table": {
+        $get: {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {
+                error: "forbidden" | "Signed out" | "No such row";
+            };
+            outputFormat: "json";
+            status: 401 | 403 | 404;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {}[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        };
+    };
+} & {
+    "/:table/public": {
+        $get: {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {}[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        };
+    };
+} & {
+    "/:table": {
+        $post: {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {
+                error: "forbidden" | "Signed out" | "No such row";
+            };
+            outputFormat: "json";
+            status: 401 | 403 | 404;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {};
+            outputFormat: "json";
+            status: 201;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {
+                error: string;
+                unique: readonly (readonly string[])[];
+            };
+            outputFormat: "json";
+            status: 409;
+        };
+    };
+} & {
+    "/:table/:id": {
+        $put: {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {
+                error: "forbidden" | "Signed out" | "No such row";
+            };
+            outputFormat: "json";
+            status: 401 | 403 | 404;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+                unique: readonly (readonly string[])[];
+            };
+            outputFormat: "json";
+            status: 409;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {};
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        };
+    };
+} & {
+    "/:table/:id": {
+        $delete: {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {
+                error: "forbidden" | "Signed out" | "No such row";
+            };
+            outputFormat: "json";
+            status: 401 | 403 | 404;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/api/tables">, "/api", "/api/me">;

package/dist/server/createServer.js

@@ -0,0 +1,82 @@
+import { Hono } from 'hono';
+import { csrf } from 'hono/csrf';
+import { adminEmails } from "../access.js";
+import { appTitle } from "../appTitle.js";
+import { auth, devSignIn } from "./auth.js";
+import { forgetSession, issuePass, needsRecheck, readPass, rememberUser } from "./session.js";
+import { renewSession } from "./sessions.js";
+import { readTitle, writeTitle } from "./settings.js";
+import { serveTables } from "./tables.js";
+import { findUser } from "./users.js";
+const PUBLIC_PATHS = ['/api/health', '/api/auth/'];
+const VIEWER_OPTIONAL_PATHS = ['/api/tables/'];
+const APP_PATH = '/api/app';
+function knowAdmins(admins) {
+    const emails = adminEmails(admins);
+    return (c, next) => {
+        c.set('admins', emails);
+        return next();
+    };
+}
+async function attachViewer(c, next) {
+    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));
+    let pass = await readPass(c);
+    if (pass !== undefined && needsRecheck(pass)) {
+        const user = await renewSession(c.env.DB, pass.sessionId);
+        pass =
+            user === undefined ? undefined : await issuePass(c, user, pass.sessionId);
+    }
+    if (pass === undefined) {
+        forgetSession(c);
+        if (!isOptional)
+            return c.json({ error: 'Signed out' }, 401);
+        c.set('viewer', null);
+        return next();
+    }
+    c.set('viewer', {
+        userId: pass.userId,
+        isAdmin: c.get('admins').has(pass.email.toLowerCase())
+    });
+    return next();
+}
+export function createServer({ tables, admins, routes }) {
+    const authRoutes = import.meta.env.DEV ? auth.route('/', devSignIn) : auth;
+    const server = new Hono()
+        .basePath('/api')
+        .use(csrf())
+        .use(knowAdmins(admins))
+        .use(attachViewer)
+        .get('/health', (c) => c.json({ ok: true }))
+        .route('/auth', authRoutes)
+        .get('/app', async (c) => c.json({ title: await readTitle(c.env.DB) }))
+        .put('/app', async (c) => {
+        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 = await c.req.json().catch(() => undefined);
+        const title = appTitle.safeParse(Reflect.get(Object(body), 'title'));
+        if (!title.success) {
+            return c.json({ error: 'title must be 1 to 60 characters' }, 400);
+        }
+        await writeTitle(c.env.DB, title.data);
+        return c.json({ title: title.data });
+    })
+        .get('/me', async (c) => {
+        const viewer = c.get('viewer');
+        const user = viewer === null ? undefined : await findUser(c.env.DB, viewer.userId);
+        if (user === undefined) {
+            forgetSession(c);
+            return c.json({ error: 'Signed out' }, 401);
+        }
+        rememberUser(c, user);
+        return c.json({ ...user, isAdmin: viewer?.isAdmin ?? false }, 200);
+    })
+        .route('/tables', serveTables(tables));
+    const own = routes;
+    return (own === undefined ? server : server.route('/', own)).notFound((c) => c.json({ error: `No route for ${c.req.path}` }, 404));
+}

package/dist/server/env.d.ts

@@ -0,0 +1,15 @@
+import type { D1Database } from '@cloudflare/workers-types';
+import type { Viewer } from '../access.ts';
+export type { Viewer };
+export type ServerBindings = {
+    DB: D1Database;
+    SESSION_SECRET: string;
+    AUTH_SECRET?: string;
+};
+export type ServerEnv<Bindings extends ServerBindings = ServerBindings> = {
+    Bindings: Bindings;
+    Variables: {
+        viewer: Viewer | null;
+        admins: ReadonlySet<string>;
+    };
+};

package/dist/server/env.js

@@ -0,0 +1 @@
+export {};

package/dist/server/index.d.ts

@@ -0,0 +1,13 @@
+export { createServer } from './createServer.ts';
+export type { ServerBindings, ServerEnv, Viewer } from './env.ts';
+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 { sessions } from './sessions.ts';
+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';

package/dist/server/index.js

@@ -0,0 +1,9 @@
+export { createServer } from "./createServer.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 { 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";

package/dist/server/services.d.ts

@@ -0,0 +1,9 @@
+import type { Context, Env } from 'hono';
+import { Hono } from 'hono';
+import type { CallInput, CallReply, Services } from '../services.ts';
+export type ServiceHandlers<Group extends Services, E extends Env> = {
+    readonly [Name in keyof Group]: {
+        readonly [Call in keyof Group[Name]]: (c: Context<E>, input: CallInput<Group[Name][Call]>) => CallReply<Group[Name][Call]> | Promise<CallReply<Group[Name][Call]>>;
+    };
+};
+export declare function serveServices<Group extends Services, E extends Env>(services: Group, handlers: ServiceHandlers<Group, E>): Hono<E>;

package/dist/server/services.js

@@ -0,0 +1,47 @@
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { ServiceRefused, paramNamesOf } from "../services.js";
+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'];
+function builtInPathOf(path) {
+    return BUILT_IN_PATHS.find((prefix) => path === prefix || path.startsWith(`${prefix}/`));
+}
+export function serveServices(services, handlers) {
+    for (const [group, calls] of Object.entries(services)) {
+        for (const [name, call] of Object.entries(calls)) {
+            const taken = builtInPathOf(call.path);
+            if (taken !== undefined) {
+                throw new Error(`${group}.${name} is served at ${call.path}, under Pattern's own ${taken}, where some calls are open to anyone signed out. Give it a path of its own.`);
+            }
+        }
+    }
+    const server = new Hono();
+    for (const [group, calls] of Object.entries(services)) {
+        for (const [name, call] of Object.entries(calls)) {
+            const handler = Reflect.get(Reflect.get(handlers, group), name);
+            server.on(call.method.toUpperCase(), call.path, async (c) => {
+                const parsed = await inputOf(c, call);
+                if (!parsed.success) {
+                    return c.json({ error: z.prettifyError(parsed.error) }, 400);
+                }
+                const params = Object.fromEntries(paramNamesOf(call.path).map((key) => [key, c.req.param(key) ?? '']));
+                try {
+                    const reply = await handler(c, {
+                        ...params,
+                        ...parsed.data
+                    });
+                    return c.json(call.reply.parse(reply));
+                }
+                catch (error) {
+                    if (!(error instanceof ServiceRefused))
+                        throw error;
+                    return c.json({ error: error.message }, error.status);
+                }
+            });
+        }
+    }
+    return server;
+}

package/dist/server/session.d.ts

@@ -0,0 +1,29 @@
+import type { Context } from 'hono';
+import { z } from 'zod';
+import type { StoredUser } from '../auth/user.ts';
+import type { ServerEnv } from './env.ts';
+declare const passSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    userId: z.ZodString;
+    email: z.ZodString;
+    recheckAt: z.ZodNumber;
+}, z.core.$strip>;
+export type Pass = z.infer<typeof passSchema>;
+export declare function rememberUser(c: Context<ServerEnv>, user: StoredUser): void;
+export declare function issuePass(c: Context<ServerEnv>, user: StoredUser, sessionId: string): Promise<{
+    sessionId: string;
+    userId: string;
+    email: string;
+    recheckAt: number;
+}>;
+export declare function startSession(c: Context<ServerEnv>, user: StoredUser): Promise<void>;
+export declare function sessionCookieFor(env: ServerEnv['Bindings'], user: StoredUser): Promise<string>;
+export declare function readPass(c: Context<ServerEnv>): Promise<{
+    sessionId: string;
+    userId: string;
+    email: string;
+    recheckAt: number;
+} | undefined>;
+export declare const needsRecheck: (pass: Pass) => boolean;
+export declare function forgetSession(c: Context<ServerEnv>): void;
+export {};

package/dist/server/session.js

@@ -0,0 +1,65 @@
+import { deleteCookie, getSignedCookie, setCookie, setSignedCookie } from 'hono/cookie';
+import { serializeSigned } from 'hono/utils/cookie';
+import { z } from 'zod';
+import { USER_COOKIE } from "../auth/user.js";
+import { createSession } from "./sessions.js";
+const SESSION_COOKIE = 'pattern_session';
+const RECHECK_SECONDS = 15 * 60;
+const SESSION_SECONDS = 30 * 86_400;
+const cookieOptions = {
+    path: '/',
+    secure: true,
+    sameSite: 'Lax',
+    maxAge: SESSION_SECONDS
+};
+const passSchema = z.object({
+    sessionId: z.string(),
+    userId: z.string(),
+    email: z.string(),
+    recheckAt: z.number()
+});
+const nowInSeconds = () => Math.floor(Date.now() / 1000);
+export function rememberUser(c, user) {
+    setCookie(c, USER_COOKIE, JSON.stringify(user), cookieOptions);
+}
+export async function issuePass(c, user, sessionId) {
+    const pass = {
+        sessionId,
+        userId: user.id,
+        email: user.email,
+        recheckAt: nowInSeconds() + RECHECK_SECONDS
+    };
+    await setSignedCookie(c, SESSION_COOKIE, JSON.stringify(pass), c.env.SESSION_SECRET, { ...cookieOptions, httpOnly: true });
+    rememberUser(c, user);
+    return pass;
+}
+export async function startSession(c, user) {
+    await issuePass(c, user, await createSession(c.env.DB, user.id));
+}
+export async function sessionCookieFor(env, user) {
+    const pass = {
+        sessionId: await createSession(env.DB, user.id),
+        userId: user.id,
+        email: user.email,
+        recheckAt: nowInSeconds() + RECHECK_SECONDS
+    };
+    const cookie = await serializeSigned(SESSION_COOKIE, JSON.stringify(pass), env.SESSION_SECRET);
+    return cookie.split(';')[0] ?? cookie;
+}
+export async function readPass(c) {
+    const value = await getSignedCookie(c, c.env.SESSION_SECRET, SESSION_COOKIE);
+    if (typeof value !== 'string')
+        return undefined;
+    try {
+        const parsed = passSchema.safeParse(JSON.parse(value));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export const needsRecheck = (pass) => pass.recheckAt <= nowInSeconds();
+export function forgetSession(c) {
+    deleteCookie(c, SESSION_COOKIE, { path: '/' });
+    deleteCookie(c, USER_COOKIE, { path: '/' });
+}