git.stevedylan.dev

chore: refactored server package to use sqlite instead of redis 7348ada4

Steve · 2026-03-07 19:52 10 file(s) · +105 −58

.gitignore +3 −0

# Finder (MacOS) folder config
.DS_Store

# SQLite data
data/

# Bun lockfile - keep but binary cache
bun.lockb
plans/

packages/server/.env.example +1 −1

CLIENT_URL=https://your-domain.com
CLIENT_NAME=Sequoia
PORT=3000
REDIS_URL=redis://redis:6379
DATABASE_PATH=./data/sequoia.db

# Theme overrides (optional)
# THEME_ACCENT_COLOR=#3A5A40

packages/server/docker-compose.yml +3 −8

      - CLIENT_URL=${CLIENT_URL}
      - CLIENT_NAME=${CLIENT_NAME:-Sequoia}
      - PORT=${PORT:-3000}
      - REDIS_URL=redis://redis:6379
      - DATABASE_PATH=${DATABASE_PATH:-/app/data/sequoia.db}
      - THEME_ACCENT_COLOR=${THEME_ACCENT_COLOR:-}
      - THEME_BG_COLOR=${THEME_BG_COLOR:-}
      - THEME_FG_COLOR=${THEME_FG_COLOR:-}

      - THEME_DARK_BORDER_COLOR=${THEME_DARK_BORDER_COLOR:-}
      - THEME_DARK_ERROR_COLOR=${THEME_DARK_ERROR_COLOR:-}
      - THEME_CSS_PATH=${THEME_CSS_PATH:-}
    depends_on:
      - redis

  redis:
    image: redis:7
    volumes:
      - redis-data:/data
      - sequoia-data:/app/data

volumes:
  redis-data:
  sequoia-data:

packages/server/src/env.ts +2 −2

	CLIENT_URL: string;
	CLIENT_NAME: string;
	PORT: number;
	REDIS_URL: string;
	DATABASE_PATH: string;
}

export function loadEnv(): Env {

		CLIENT_URL: CLIENT_URL.replace(/\/+$/, ""),
		CLIENT_NAME: process.env.CLIENT_NAME || "Sequoia",
		PORT: Number(process.env.PORT) || 3000,
		REDIS_URL: process.env.REDIS_URL || "redis://localhost:6379",
		DATABASE_PATH: process.env.DATABASE_PATH || "./data/sequoia.db",
	};
}

packages/server/src/index.ts +5 −5

import { Hono } from "hono";
import { cors } from "hono/cors";
import { RedisClient } from "bun";
import { loadEnv } from "./env";
import type { Env } from "./env";
import { openDatabase } from "./lib/db";
import auth from "./routes/auth";
import subscribe from "./routes/subscribe";

const env = loadEnv();

const redis = new RedisClient(env.REDIS_URL);
const db = openDatabase(env.DATABASE_PATH);

type Variables = { env: Env; redis: typeof redis };
type Variables = { env: Env; db: typeof db };

const app = new Hono<{ Variables: Variables }>();

// Inject env and redis into all routes
// Inject env and db into all routes
app.use("*", async (c, next) => {
	c.set("env", env);
	c.set("redis", redis);
	c.set("db", db);
	await next();
});


packages/server/src/lib/db.ts (added) +53 −0

1	+	import { Database } from "bun:sqlite";
2	+	import { mkdirSync } from "node:fs";
3	+	import { dirname } from "node:path";
4	+
5	+	export function openDatabase(path: string): Database {
6	+	mkdirSync(dirname(path), { recursive: true });
7	+
8	+	const db = new Database(path);
9	+	db.run("PRAGMA journal_mode = WAL");
10	+	db.run(`
11	+	CREATE TABLE IF NOT EXISTS kv (
12	+	key TEXT PRIMARY KEY,
13	+	value TEXT NOT NULL,
14	+	expires_at INTEGER
15	+	)
16	+	`);
17	+	return db;
18	+	}
19	+
20	+	export function kvGet(db: Database, key: string): string \| undefined {
21	+	const row = db
22	+	.query<{ value: string; expires_at: number \| null }, [string]>(
23	+	"SELECT value, expires_at FROM kv WHERE key = ?",
24	+	)
25	+	.get(key);
26	+
27	+	if (!row) return undefined;
28	+
29	+	if (row.expires_at !== null && row.expires_at <= Date.now()) {
30	+	db.run("DELETE FROM kv WHERE key = ?", [key]);
31	+	return undefined;
32	+	}
33	+
34	+	return row.value;
35	+	}
36	+
37	+	export function kvSet(
38	+	db: Database,
39	+	key: string,
40	+	value: string,
41	+	ttlSeconds?: number,
42	+	): void {
43	+	const expiresAt =
44	+	ttlSeconds !== undefined ? Date.now() + ttlSeconds * 1000 : null;
45	+	db.run(
46	+	"INSERT OR REPLACE INTO kv (key, value, expires_at) VALUES (?, ?, ?)",
47	+	[key, value, expiresAt],
48	+	);
49	+	}
50	+
51	+	export function kvDel(db: Database, key: string): void {
52	+	db.run("DELETE FROM kv WHERE key = ?", [key]);
53	+	}

packages/server/src/lib/oauth-client.ts +5 −5

import { JoseKey } from "@atproto/jwk-jose";
import { OAuthClient } from "@atproto/oauth-client";
import { AtprotoDohHandleResolver } from "@atproto-labs/handle-resolver";
import type { RedisClient } from "bun";
import { createStateStore, createSessionStore } from "./redis-stores";
import type { Database } from "bun:sqlite";
import { createStateStore, createSessionStore } from "./stores";

export const OAUTH_SCOPE =
	"atproto repo:site.standard.graph.subscription?action=create&action=delete";

export function createOAuthClient(
	redis: RedisClient,
	db: Database,
	clientUrl: string,
	clientName = "Sequoia",
) {

			},
			requestLock: <T>(_name: string, fn: () => T | PromiseLike<T>) => fn(),
		},
		stateStore: createStateStore(redis),
		sessionStore: createSessionStore(redis),
		stateStore: createStateStore(db),
		sessionStore: createSessionStore(db),
	});
}

packages/server/src/lib/redis-stores.ts → packages/server/src/lib/stores.ts +10 −13

	SessionStore,
	StateStore,
} from "@atproto/oauth-client";
import { RedisClient } from "bun";
import type { Database } from "bun:sqlite";
import { kvGet, kvSet, kvDel } from "./db";

type SerializedStateData = Omit<InternalStateData, "dpopKey"> & {
	dpopJwk: Record<string, unknown>;

	return JoseKey.fromJWK(jwk) as unknown as Key;
}

export function createStateStore(redis: RedisClient, ttl = 600): StateStore {
export function createStateStore(db: Database, ttl = 600): StateStore {
	return {
		async set(key, { dpopKey, ...rest }) {
			const data: SerializedStateData = {
				...rest,
				dpopJwk: serializeKey(dpopKey),
			};
			const redisKey = `oauth_state:${key}`;
			await redis.set(redisKey, JSON.stringify(data));
			await redis.expire(redisKey, ttl);
			kvSet(db, `oauth_state:${key}`, JSON.stringify(data), ttl);
		},
		async get(key) {
			const raw = await redis.get(`oauth_state:${key}`);
			const raw = kvGet(db, `oauth_state:${key}`);
			if (!raw) return undefined;
			const { dpopJwk, ...rest }: SerializedStateData = JSON.parse(raw);
			const dpopKey = await deserializeKey(dpopJwk);
			return { ...rest, dpopKey };
		},
		async del(key) {
			await redis.del(`oauth_state:${key}`);
			kvDel(db, `oauth_state:${key}`);
		},
	};
}

export function createSessionStore(
	redis: RedisClient,
	db: Database,
	ttl = 60 * 60 * 24 * 14,
): SessionStore {
	return {

				...rest,
				dpopJwk: serializeKey(dpopKey),
			};
			const redisKey = `oauth_session:${sub}`;
			await redis.set(redisKey, JSON.stringify(data));
			await redis.expire(redisKey, ttl);
			kvSet(db, `oauth_session:${sub}`, JSON.stringify(data), ttl);
		},
		async get(sub) {
			const raw = await redis.get(`oauth_session:${sub}`);
			const raw = kvGet(db, `oauth_session:${sub}`);
			if (!raw) return undefined;
			const { dpopJwk, ...rest }: SerializedSession = JSON.parse(raw);
			const dpopKey = await deserializeKey(dpopJwk);
			return { ...rest, dpopKey };
		},
		async del(sub) {
			await redis.del(`oauth_session:${sub}`);
			kvDel(db, `oauth_session:${sub}`);
		},
	};
}

packages/server/src/routes/auth.ts +15 −16

import { Hono } from "hono";
import type { RedisClient } from "bun";
import type { Database } from "bun:sqlite";
import { createOAuthClient, OAUTH_SCOPE } from "../lib/oauth-client";
import { kvGet, kvSet, kvDel } from "../lib/db";
import {
	getSessionDid,
	setSessionCookie,

} from "../lib/session";
import type { Env } from "../env";

type Variables = { env: Env; redis: RedisClient };
type Variables = { env: Env; db: Database };

const auth = new Hono<{ Variables: Variables }>();


// Start OAuth login flow
auth.get("/login", async (c) => {
	const env = c.get("env");
	const redis = c.get("redis");
	const db = c.get("db");

	try {
		const handle = c.req.query("handle");

			return c.redirect(`${env.CLIENT_URL}/?error=missing_handle`);
		}

		const client = createOAuthClient(redis, env.CLIENT_URL, env.CLIENT_NAME);
		const client = createOAuthClient(db, env.CLIENT_URL, env.CLIENT_NAME);
		const authUrl = await client.authorize(handle, {
			scope: OAUTH_SCOPE,
		});

// OAuth callback handler
auth.get("/callback", async (c) => {
	const env = c.get("env");
	const redis = c.get("redis");
	const db = c.get("db");

	try {
		const params = new URLSearchParams(c.req.url.split("?")[1] || "");

			);
		}

		const client = createOAuthClient(redis, env.CLIENT_URL, env.CLIENT_NAME);
		const client = createOAuthClient(db, env.CLIENT_URL, env.CLIENT_NAME);
		const { session } = await client.callback(params);

		// Resolve handle from DID

			// Handle resolution is best-effort
		}

		// Store handle in Redis alongside the session for quick lookup
		// Store handle alongside the session for quick lookup
		if (handle) {
			const key = `oauth_handle:${session.did}`;
			await redis.set(key, handle);
			await redis.expire(key, 60 * 60 * 24 * 14);
			kvSet(db, `oauth_handle:${session.did}`, handle, 60 * 60 * 24 * 14);
		}

		setSessionCookie(c, session.did, env.CLIENT_URL);

// Logout endpoint
auth.post("/logout", async (c) => {
	const env = c.get("env");
	const redis = c.get("redis");
	const db = c.get("db");
	const did = getSessionDid(c);

	if (did) {
		try {
			const client = createOAuthClient(redis, env.CLIENT_URL, env.CLIENT_NAME);
			const client = createOAuthClient(db, env.CLIENT_URL, env.CLIENT_NAME);
			await client.revoke(did);
		} catch (error) {
			console.error("Revoke error:", error);
		}
		await redis.del(`oauth_handle:${did}`);
		kvDel(db, `oauth_handle:${did}`);
	}

	clearSessionCookie(c, env.CLIENT_URL);

// Check auth status
auth.get("/status", async (c) => {
	const env = c.get("env");
	const redis = c.get("redis");
	const db = c.get("db");
	const did = getSessionDid(c);

	if (!did) {

	}

	try {
		const client = createOAuthClient(redis, env.CLIENT_URL, env.CLIENT_NAME);
		const client = createOAuthClient(db, env.CLIENT_URL, env.CLIENT_NAME);
		const session = await client.restore(did);

		const handle = await redis.get(`oauth_handle:${session.did}`);
		const handle = kvGet(db, `oauth_handle:${session.did}`);

		return c.json({
			authenticated: true,

packages/server/src/routes/subscribe.ts +8 −8

import { Agent } from "@atproto/api";
import { Hono } from "hono";
import type { RedisClient } from "bun";
import type { Database } from "bun:sqlite";
import { createOAuthClient } from "../lib/oauth-client";
import { getSessionDid, setReturnToCookie } from "../lib/session";
import { page, escapeHtml } from "../lib/theme";
import type { Env } from "../env";

type Variables = { env: Env; redis: RedisClient };
type Variables = { env: Env; db: Database };

const subscribe = new Hono<{ Variables: Variables }>();



subscribe.post("/", async (c) => {
	const env = c.get("env");
	const redis = c.get("redis");
	const db = c.get("db");

	let publicationUri: string;
	try {

	}

	try {
		const client = createOAuthClient(redis, env.CLIENT_URL, env.CLIENT_NAME);
		const client = createOAuthClient(db, env.CLIENT_URL, env.CLIENT_NAME);
		const session = await client.restore(did);
		const agent = new Agent(session);



subscribe.get("/", async (c) => {
	const env = c.get("env");
	const redis = c.get("redis");
	const db = c.get("db");

	const publicationUri = c.req.query("publicationUri");
	const action = c.req.query("action");

	}

	try {
		const client = createOAuthClient(redis, env.CLIENT_URL, env.CLIENT_NAME);
		const client = createOAuthClient(db, env.CLIENT_URL, env.CLIENT_NAME);
		const session = await client.restore(did);
		const agent = new Agent(session);



subscribe.get("/check", async (c) => {
	const env = c.get("env");
	const redis = c.get("redis");
	const db = c.get("db");

	const publicationUri = c.req.query("publicationUri");


	}

	try {
		const client = createOAuthClient(redis, env.CLIENT_URL, env.CLIENT_NAME);
		const client = createOAuthClient(db, env.CLIENT_URL, env.CLIENT_NAME);
		const session = await client.restore(did);
		const agent = new Agent(session);
		const recordUri = await findExistingSubscription(

1	1		import { Agent } from "@atproto/api";
2	2		import { Hono } from "hono";
3		-	import type { RedisClient } from "bun";
	3	+	import type { Database } from "bun:sqlite";
4	4		import { createOAuthClient } from "../lib/oauth-client";
5	5		import { getSessionDid, setReturnToCookie } from "../lib/session";
6	6		import { page, escapeHtml } from "../lib/theme";
7	7		import type { Env } from "../env";
8	8
9		-	type Variables = { env: Env; redis: RedisClient };
	9	+	type Variables = { env: Env; db: Database };
10	10
11	11		const subscribe = new Hono<{ Variables: Variables }>();
12	12

66	66
67	67		subscribe.post("/", async (c) => {
68	68		const env = c.get("env");
69		-	const redis = c.get("redis");
	69	+	const db = c.get("db");
70	70
71	71		let publicationUri: string;
72	72		try {

87	87		}
88	88
89	89		try {
90		-	const client = createOAuthClient(redis, env.CLIENT_URL, env.CLIENT_NAME);
	90	+	const client = createOAuthClient(db, env.CLIENT_URL, env.CLIENT_NAME);
91	91		const session = await client.restore(did);
92	92		const agent = new Agent(session);
93	93

131	131
132	132		subscribe.get("/", async (c) => {
133	133		const env = c.get("env");
134		-	const redis = c.get("redis");
	134	+	const db = c.get("db");
135	135
136	136		const publicationUri = c.req.query("publicationUri");
137	137		const action = c.req.query("action");

157	157		}
158	158
159	159		try {
160		-	const client = createOAuthClient(redis, env.CLIENT_URL, env.CLIENT_NAME);
	160	+	const client = createOAuthClient(db, env.CLIENT_URL, env.CLIENT_NAME);
161	161		const session = await client.restore(did);
162	162		const agent = new Agent(session);
163	163

256	256
257	257		subscribe.get("/check", async (c) => {
258	258		const env = c.get("env");
259		-	const redis = c.get("redis");
	259	+	const db = c.get("db");
260	260
261	261		const publicationUri = c.req.query("publicationUri");
262	262

270	270		}
271	271
272	272		try {
273		-	const client = createOAuthClient(redis, env.CLIENT_URL, env.CLIENT_NAME);
	273	+	const client = createOAuthClient(db, env.CLIENT_URL, env.CLIENT_NAME);
274	274		const session = await client.restore(did);
275	275		const agent = new Agent(session);
276	276		const recordUri = await findExistingSubscription(

33	33		# Finder (MacOS) folder config
34	34		.DS_Store
35	35
	36	+	# SQLite data
	37	+	data/
	38	+
36	39		# Bun lockfile - keep but binary cache
37	40		bun.lockb
38	41		plans/

1	1		CLIENT_URL=https://your-domain.com
2	2		CLIENT_NAME=Sequoia
3	3		PORT=3000
4		-	REDIS_URL=redis://redis:6379
	4	+	DATABASE_PATH=./data/sequoia.db
5	5
6	6		# Theme overrides (optional)
7	7		# THEME_ACCENT_COLOR=#3A5A40

7	7		- CLIENT_URL=${CLIENT_URL}
8	8		- CLIENT_NAME=${CLIENT_NAME:-Sequoia}
9	9		- PORT=${PORT:-3000}
10		-	- REDIS_URL=redis://redis:6379
	10	+	- DATABASE_PATH=${DATABASE_PATH:-/app/data/sequoia.db}
11	11		- THEME_ACCENT_COLOR=${THEME_ACCENT_COLOR:-}
12	12		- THEME_BG_COLOR=${THEME_BG_COLOR:-}
13	13		- THEME_FG_COLOR=${THEME_FG_COLOR:-}

20	20		- THEME_DARK_BORDER_COLOR=${THEME_DARK_BORDER_COLOR:-}
21	21		- THEME_DARK_ERROR_COLOR=${THEME_DARK_ERROR_COLOR:-}
22	22		- THEME_CSS_PATH=${THEME_CSS_PATH:-}
23		-	depends_on:
24		-	- redis
25		-
26		-	redis:
27		-	image: redis:7
28	23		volumes:
29		-	- redis-data:/data
	24	+	- sequoia-data:/app/data
30	25
31	26		volumes:
32		-	redis-data:
	27	+	sequoia-data:

2	2		CLIENT_URL: string;
3	3		CLIENT_NAME: string;
4	4		PORT: number;
5		-	REDIS_URL: string;
	5	+	DATABASE_PATH: string;
6	6		}
7	7
8	8		export function loadEnv(): Env {

15	15		CLIENT_URL: CLIENT_URL.replace(/\/+$/, ""),
16	16		CLIENT_NAME: process.env.CLIENT_NAME \|\| "Sequoia",
17	17		PORT: Number(process.env.PORT) \|\| 3000,
18		-	REDIS_URL: process.env.REDIS_URL \|\| "redis://localhost:6379",
	18	+	DATABASE_PATH: process.env.DATABASE_PATH \|\| "./data/sequoia.db",
19	19		};
20	20		}

1	1		import { Hono } from "hono";
2	2		import { cors } from "hono/cors";
3		-	import { RedisClient } from "bun";
4	3		import { loadEnv } from "./env";
5	4		import type { Env } from "./env";
	5	+	import { openDatabase } from "./lib/db";
6	6		import auth from "./routes/auth";
7	7		import subscribe from "./routes/subscribe";
8	8
9	9		const env = loadEnv();
10	10
11		-	const redis = new RedisClient(env.REDIS_URL);
	11	+	const db = openDatabase(env.DATABASE_PATH);
12	12
13		-	type Variables = { env: Env; redis: typeof redis };
	13	+	type Variables = { env: Env; db: typeof db };
14	14
15	15		const app = new Hono<{ Variables: Variables }>();
16	16
17		-	// Inject env and redis into all routes
	17	+	// Inject env and db into all routes
18	18		app.use("*", async (c, next) => {
19	19		c.set("env", env);
20		-	c.set("redis", redis);
	20	+	c.set("db", db);
21	21		await next();
22	22		});
23	23

1	1		import { JoseKey } from "@atproto/jwk-jose";
2	2		import { OAuthClient } from "@atproto/oauth-client";
3	3		import { AtprotoDohHandleResolver } from "@atproto-labs/handle-resolver";
4		-	import type { RedisClient } from "bun";
5		-	import { createStateStore, createSessionStore } from "./redis-stores";
	4	+	import type { Database } from "bun:sqlite";
	5	+	import { createStateStore, createSessionStore } from "./stores";
6	6
7	7		export const OAUTH_SCOPE =
8	8		"atproto repo:site.standard.graph.subscription?action=create&action=delete";
9	9
10	10		export function createOAuthClient(
11		-	redis: RedisClient,
	11	+	db: Database,
12	12		clientUrl: string,
13	13		clientName = "Sequoia",
14	14		) {

47	47		},
48	48		requestLock: <T>(_name: string, fn: () => T \| PromiseLike<T>) => fn(),
49	49		},
50		-	stateStore: createStateStore(redis),
51		-	sessionStore: createSessionStore(redis),
	50	+	stateStore: createStateStore(db),
	51	+	sessionStore: createSessionStore(db),
52	52		});
53	53		}

5	5		SessionStore,
6	6		StateStore,
7	7		} from "@atproto/oauth-client";
8		-	import { RedisClient } from "bun";
	8	+	import type { Database } from "bun:sqlite";
	9	+	import { kvGet, kvSet, kvDel } from "./db";
9	10
10	11		type SerializedStateData = Omit<InternalStateData, "dpopKey"> & {
11	12		dpopJwk: Record<string, unknown>;

25	26		return JoseKey.fromJWK(jwk) as unknown as Key;
26	27		}
27	28
28		-	export function createStateStore(redis: RedisClient, ttl = 600): StateStore {
	29	+	export function createStateStore(db: Database, ttl = 600): StateStore {
29	30		return {
30	31		async set(key, { dpopKey, ...rest }) {
31	32		const data: SerializedStateData = {
32	33		...rest,
33	34		dpopJwk: serializeKey(dpopKey),
34	35		};
35		-	const redisKey = `oauth_state:${key}`;
36		-	await redis.set(redisKey, JSON.stringify(data));
37		-	await redis.expire(redisKey, ttl);
	36	+	kvSet(db, `oauth_state:${key}`, JSON.stringify(data), ttl);
38	37		},
39	38		async get(key) {
40		-	const raw = await redis.get(`oauth_state:${key}`);
	39	+	const raw = kvGet(db, `oauth_state:${key}`);
41	40		if (!raw) return undefined;
42	41		const { dpopJwk, ...rest }: SerializedStateData = JSON.parse(raw);
43	42		const dpopKey = await deserializeKey(dpopJwk);
44	43		return { ...rest, dpopKey };
45	44		},
46	45		async del(key) {
47		-	await redis.del(`oauth_state:${key}`);
	46	+	kvDel(db, `oauth_state:${key}`);
48	47		},
49	48		};
50	49		}
51	50
52	51		export function createSessionStore(
53		-	redis: RedisClient,
	52	+	db: Database,
54	53		ttl = 60 * 60 * 24 * 14,
55	54		): SessionStore {
56	55		return {

59	58		...rest,
60	59		dpopJwk: serializeKey(dpopKey),
61	60		};
62		-	const redisKey = `oauth_session:${sub}`;
63		-	await redis.set(redisKey, JSON.stringify(data));
64		-	await redis.expire(redisKey, ttl);
	61	+	kvSet(db, `oauth_session:${sub}`, JSON.stringify(data), ttl);
65	62		},
66	63		async get(sub) {
67		-	const raw = await redis.get(`oauth_session:${sub}`);
	64	+	const raw = kvGet(db, `oauth_session:${sub}`);
68	65		if (!raw) return undefined;
69	66		const { dpopJwk, ...rest }: SerializedSession = JSON.parse(raw);
70	67		const dpopKey = await deserializeKey(dpopJwk);
71	68		return { ...rest, dpopKey };
72	69		},
73	70		async del(sub) {
74		-	await redis.del(`oauth_session:${sub}`);
	71	+	kvDel(db, `oauth_session:${sub}`);
75	72		},
76	73		};
77	74		}