@trypattern/sdk 0.0.0-stage → 0.1.0

package/dist/server/createServer.d.ts

@@ -0,0 +1,357 @@
+import type { Tables } from '../table.ts';
+import type { ServerEnv } from './env.ts';
+export declare function createServer<Group extends Tables>({ tables, admins }: {
+    tables: Group;
+    admins: readonly string[];
+}): 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/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,62 @@
+import { Hono } from 'hono';
+import { csrf } from 'hono/csrf';
+import { adminEmails } from "../access.js";
+import { auth, devSignIn } from "./auth.js";
+import { forgetSession, issuePass, needsRecheck, readPass, rememberUser } from "./session.js";
+import { renewSession } from "./sessions.js";
+import { serveTables } from "./tables.js";
+import { findUser } from "./users.js";
+const PUBLIC_PATHS = ['/api/health', '/api/auth/'];
+const VIEWER_OPTIONAL_PATHS = ['/api/tables/'];
+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 = 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 }) {
+    const authRoutes = import.meta.env.DEV ? auth.route('/', devSignIn) : auth;
+    return new Hono()
+        .basePath('/api')
+        .use(csrf())
+        .use(knowAdmins(admins))
+        .use(attachViewer)
+        .get('/health', (c) => c.json({ ok: true }))
+        .route('/auth', authRoutes)
+        .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))
+        .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: ServerBindings;
+    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,8 @@
+export { createServer } from './createServer.ts';
+export type { ServerBindings, ServerEnv, Viewer } from './env.ts';
+export { seedSql, serveTables, sqlTable, sqlTables } from './tables.ts';
+export { sessions } from './sessions.ts';
+export { exchangeReply, exchangeRequest, sendCodeReply, sendCodeRequest, verifiedIdentity, verifyCodeReply, verifyCodeRequest } from './signInWire.ts';
+export type { VerifiedIdentity } from './signInWire.ts';
+export { users } from './users.ts';
+export type { D1Database } from '@cloudflare/workers-types';

package/dist/server/index.js

@@ -0,0 +1,5 @@
+export { createServer } from "./createServer.js";
+export { seedSql, serveTables, sqlTable, sqlTables } from "./tables.js";
+export { sessions } from "./sessions.js";
+export { exchangeReply, exchangeRequest, sendCodeReply, sendCodeRequest, verifiedIdentity, verifyCodeReply, verifyCodeRequest } from "./signInWire.js";
+export { users } from "./users.js";

package/dist/server/session.d.ts

@@ -0,0 +1,28 @@
+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 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,54 @@
+import { deleteCookie, getSignedCookie, setCookie, setSignedCookie } from 'hono/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 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: '/' });
+}

package/dist/server/sessions.d.ts

@@ -0,0 +1,92 @@
+import type { D1Database } from '@cloudflare/workers-types';
+export declare const sessions: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "sessions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "user_id";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        expiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "expires_at";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export declare function createSession(d1: D1Database, userId: string): Promise<`${string}-${string}-${string}-${string}-${string}`>;
+export declare function renewSession(d1: D1Database, id: string): Promise<{
+    id: string;
+    email: string;
+    name: string;
+    avatarUrl: string | null;
+} | undefined>;
+export declare function deleteSession(d1: D1Database, id: string): Promise<void>;

package/dist/server/sessions.js

@@ -0,0 +1,47 @@
+import { and, eq, gt, lt, sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/d1';
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { userColumns, users } from "./users.js";
+export const sessions = sqliteTable('sessions', {
+    id: text('id').primaryKey(),
+    userId: text('user_id')
+        .notNull()
+        .references(() => users.id, { onDelete: 'cascade' }),
+    expiresAt: text('expires_at').notNull(),
+    createdAt: text('created_at')
+        .notNull()
+        .default(sql `(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`)
+});
+const SESSION_DAYS = 30;
+const DAY_MILLISECONDS = 86_400_000;
+const sessionEnd = () => new Date(Date.now() + SESSION_DAYS * DAY_MILLISECONDS).toISOString();
+export async function createSession(d1, userId) {
+    const db = drizzle(d1);
+    const id = crypto.randomUUID();
+    await db.batch([
+        db
+            .delete(sessions)
+            .where(and(eq(sessions.userId, userId), lt(sessions.expiresAt, new Date().toISOString()))),
+        db.insert(sessions).values({ id, userId, expiresAt: sessionEnd() })
+    ]);
+    return id;
+}
+export async function renewSession(d1, id) {
+    const db = drizzle(d1);
+    const user = await db
+        .select(userColumns)
+        .from(sessions)
+        .innerJoin(users, eq(users.id, sessions.userId))
+        .where(and(eq(sessions.id, id), gt(sessions.expiresAt, new Date().toISOString())))
+        .get();
+    if (user === undefined)
+        return undefined;
+    await db
+        .update(sessions)
+        .set({ expiresAt: sessionEnd() })
+        .where(eq(sessions.id, id));
+    return user;
+}
+export async function deleteSession(d1, id) {
+    await drizzle(d1).delete(sessions).where(eq(sessions.id, id));
+}