Something went wrong. Try again.
[READ-ONLY] Mirror of https://github.com/nperez0111/bookhive. Track your books, share your shelves, see what others are reading bookhive.buzz
atproto bluesky books bookshelf goodreads management-system
Something went wrong. Try again.
TypeScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332import type { ProfileViewDetailed } from "./types";import type { ActorIdentifier } from "@atcute/lexicons/syntax";import type { Did } from "@atcute/lexicons";import type { OAuthClient } from "@atcute/oauth-node-client";import type { Ingester } from "./bsky/ingester";import type { Context } from "hono";import { Hono } from "hono";import { endTime, startTime, type TimingVariables } from "hono/timing";import { getIronSession } from "iron-session";import type { Logger } from "pino";import { createStorage, type Storage } from "unstorage";import lruCacheDriver from "unstorage/drivers/lru-cache";
import { createOAuthClient, sessionClientFromOAuthSession, type SessionClient,} from "./auth/client";import { createServiceAccountAgent } from "./utils/catalogBookService";import { getSessionConfig } from "./auth/router";import { createBaseIdResolver, createBidirectionalResolverAtcute, createCachingBaseIdResolver, createCachingBidirectionalResolver,} from "./bsky/id-resolver";import type { BidirectionalResolver } from "./bsky/id-resolver";import type { Database } from "./db";import { createDb, migrateToLatest } from "./db";import { env } from "./env";import { getLogger } from "./logger/index.ts";import sqliteKv, { createSharedKvDb } from "./sqlite-kv.ts";import { lazy } from "./utils/lazy";import { readThroughCache } from "./utils/readThroughCache";
/** Add business context to the single wide event emitted at request end. Prefer this over logger.info in handlers. */export type AddWideEventContext = (context: Record<string, unknown>) => void;
/** Minimal context needed by shared book utilities (getBook, ensureBookCataloged, etc.). */export type BookUtilContext = { db: Database; kv: Storage; serviceAccountAgent: SessionClient | null; addWideEventContext: AddWideEventContext;};
// Application state passed to the router and elsewhere. No logger – request observability is via addWideEventContext + wide-event middleware.export type AppContext = { db: Database; kv: Storage; ingester: Ingester; oauthClient: OAuthClient; resolver: BidirectionalResolver; baseIdResolver: ReturnType<typeof createBaseIdResolver>; getSessionAgent: () => Promise<SessionClient | null>; getProfile: () => Promise<ProfileViewDetailed | null>; /** Service account agent for @bookhive.buzz ATProto writes. Null if env vars not set. */ serviceAccountAgent: SessionClient | null; /** Add fields to the one wide event logged per request (observability). */ addWideEventContext: AddWideEventContext;};
import type { BundleAssetUrls } from "./utils/manifest";
declare module "hono" { interface ContextVariableMap { ctx: AppContext; assetUrls: BundleAssetUrls | null; /** Request ID (UUID); set by wide-event middleware for the rest of the request. */ requestId: string; /** Mutable bag for wide-event context; merged into the single request log. */ wideEventBag: Record<string, unknown>; /** App logger; only wide-event middleware should call it for request-scoped logs. */ appLogger: Logger; /** Set by error-capture middleware (thrown) or by handlers (caught then return 5xx); included in wide-event log. */ requestError?: unknown; }}
export type AppEnv = { Variables: TimingVariables & { ctx: AppContext; assetUrls: BundleAssetUrls | null; requestId: string; appLogger: Logger; requestError?: unknown; };};
export type HonoServer = Hono<AppEnv>;
export type Session = { did: string };
/** Long-lived dependencies created at server startup (no request-scoped helpers). */export type AppDeps = { db: Database; kv: Storage; logger: Logger; oauthClient: OAuthClient; baseIdResolver: ReturnType<typeof createBaseIdResolver>; ingester: Ingester; resolver: BidirectionalResolver; serviceAccountAgent: SessionClient | null;};
export async function createAppDeps(): Promise<AppDeps> { const logger = getLogger({ name: "server", redact: { paths: ["req.headers.cookie"], censor: "***REDACTED***", }, });
const { db, sqlite } = createDb(env.DB_PATH); logger.info("starting DB migrations"); const migrationStart = Date.now(); const migrationResults = await migrateToLatest(db, sqlite); logger.info({ durationMs: Date.now() - migrationStart }, "db migrations completed"); if (migrationResults.length > 0) { logger.info( { migrations: migrationResults.map((r) => r.migrationName) }, "migrations applied, deferring VACUUM to background", ); // Run VACUUM in the background — it reclaims space but shouldn't block server startup. setTimeout(() => { const vacuumStart = Date.now(); sqlite.exec("VACUUM"); logger.info({ durationMs: Date.now() - vacuumStart }, "db VACUUM complete"); }, 5_000); }
// Single shared connection for all KV tables on KV_DB_PATH. const kvDb = createSharedKvDb(env.KV_DB_PATH); const kv = createStorage({ driver: sqliteKv({ table: "kv", db: kvDb }), });
if (env.isProd) { kv.mount("search:", lruCacheDriver({ max: 1000 })); } kv.mount("profile:", sqliteKv({ table: "profile", db: kvDb })); kv.mount("identity:", sqliteKv({ table: "identity", db: kvDb })); kv.mount("follows_sync:", sqliteKv({ table: "follows_sync", db: kvDb }));
// Auth tables: in development use a separate file; in production share the main KV connection. const authKvDb = env.isDevelopment ? createSharedKvDb("./auth.sqlite") : kvDb; kv.mount("auth_session:", sqliteKv({ table: "auth_sessions", db: authKvDb })); kv.mount("auth_state:", sqliteKv({ table: "auth_state", db: authKvDb })); kv.mount("book_lock:", lruCacheDriver({ max: 1000 }));
const oauthClient = await createOAuthClient(kv); const baseIdResolver = createCachingBaseIdResolver(kv, createBaseIdResolver()); const resolver = createCachingBidirectionalResolver(kv, createBidirectionalResolverAtcute());
const serviceAccountAgent = env.BOOKHIVE_SERVICE_HANDLE && env.BOOKHIVE_APP_PASSWORD ? await createServiceAccountAgent(env.BOOKHIVE_SERVICE_HANDLE, env.BOOKHIVE_APP_PASSWORD) : null;
// When running the Nitro bundle (.output/server/index.mjs), load the pre-built worker. // In dev, Bun runs the .ts source directly. const isBundled = import.meta.url.includes(".output/"); const workerUrl = isBundled ? new URL("./ingester-worker.js", import.meta.url).href : new URL("./workers/ingester-worker.ts", import.meta.url).href; const ingesterWorker = new Worker(workerUrl); ingesterWorker.onmessage = (event: MessageEvent) => { if (event.data.type === "wideEvent") { logger.info(event.data.payload); } else if (event.data.type === "ready") { logger.info("ingester worker ready"); } }; ingesterWorker.onerror = (event) => { logger.error({ error: event.message }, "ingester worker error"); }; const ingester: Ingester = { start() {}, destroy() { ingesterWorker.terminate(); return Promise.resolve(); }, };
return { db, kv, logger, oauthClient, baseIdResolver, ingester, resolver, serviceAccountAgent, };}
/** Optional timing callbacks for server-timing breakdown (session_iron, session_restore, session_save). */export type SessionTiming = { start: (name: string) => void; end: (name: string) => void;};
const SESSION_CLIENT_CACHE_TTL_MS = 30_000; // 30s in-memory cache to avoid restore+getTokenInfo on every requestconst sessionClientCache = new Map<string, { client: SessionClient; expiresAt: number }>();
function getCachedSessionClient(did: string): SessionClient | null { const entry = sessionClientCache.get(did); if (!entry || Date.now() > entry.expiresAt) return null; return entry.client;}
function setCachedSessionClient(did: string, client: SessionClient): void { sessionClientCache.set(did, { client, expiresAt: Date.now() + SESSION_CLIENT_CACHE_TTL_MS, });}
// Helper function to get the session client for the active sessionexport async function getSessionAgent( req: Request, res: Response, ctx: AppContext, timing?: SessionTiming,): Promise<SessionClient | null> { timing?.start("session_iron"); const session = await getIronSession<Session>(req, res, getSessionConfig()); timing?.end("session_iron");
if (!session.did) { return null; }
const cached = getCachedSessionClient(session.did); if (cached) { return cached; }
try { timing?.start("session_restore"); const oauthSession = await ctx.oauthClient.restore(session.did as Did, { refresh: "auto", }); timing?.end("session_restore");
// Don't await getTokenInfo: OAuthSession.handle() calls getTokenSet('auto') on first // request, so the token is loaded/refreshed when we first use the client (e.g. getProfile).
timing?.start("session_save"); session.updateConfig(getSessionConfig()); await session.save(); timing?.end("session_save");
const client = sessionClientFromOAuthSession(oauthSession); setCachedSessionClient(session.did, client); return client; } catch (err) { ctx.addWideEventContext({ oauth_restore: "failed", error: err instanceof Error ? err.message : String(err), }); session.destroy(); return null; }}
/** Middleware that sets request-scoped AppContext (deps + getSessionAgent, getProfile). Use on any Hono app that needs c.get("ctx"). */export function createContextMiddleware(deps: AppDeps) { return async (c: Context<AppEnv>, next: () => Promise<void>) => { c.set("wideEventBag", {}); c.set("appLogger", deps.logger);
const { logger: _logger, ...restDeps } = deps; const ctx: AppContext = { ...restDeps, addWideEventContext(context: Record<string, unknown>) { Object.assign(c.get("wideEventBag"), context); }, getSessionAgent(): Promise<SessionClient | null> { return sessionLazy.value; }, async getProfile(): Promise<ProfileViewDetailed | null> { return profileLazy.value as Promise<ProfileViewDetailed | null>; }, }; const sessionTiming: SessionTiming = { start: (name) => startTime(c, name), end: (name) => endTime(c, name), }; const sessionLazy = lazy(() => getSessionAgent(c.req.raw, c.res, ctx, sessionTiming).then((client) => { if (client) { ctx.addWideEventContext({ userDid: client.did }); } return client; }), ); const profileLazy = lazy(async () => { startTime(c, "get_profile_session"); const client = await sessionLazy.value; endTime(c, "get_profile_session"); if (!client?.did) { return null; } startTime(c, "get_profile_cache"); const result = await readThroughCache<ProfileViewDetailed | null>( deps.kv, "profile:" + client.did, async () => { startTime(c, "get_profile_network"); try { const res = await client.get("app.bsky.actor.getProfile", { params: { actor: client.did as ActorIdentifier }, }); if (!res.ok) return null; return res.data as ProfileViewDetailed | null; } finally { endTime(c, "get_profile_network"); } }, undefined, { revalidateAfter: 24 * 60 * 60 * 1000, ttl: 30 * 24 * 60 * 60 * 1000 }, ); endTime(c, "get_profile_cache"); return result; }); c.set("ctx", ctx); await next(); };}