@yaebal/panel 0.0.1 → 0.0.4

package/src/serve.ts

@@ -0,0 +1,65 @@
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+
+/** options for the node {@link serve} helper. */
+export interface ServeOptions {
+	/** port to listen on. */
+	port: number;
+	/** host/interface to bind. defaults to node's default (all interfaces). */
+	host?: string;
+	/** invoked once the server is listening. */
+	onListen?: (info: { port: number; host?: string }) => void;
+}
+
+/** translate a node request into a whatwg `Request` (body streamed for non-GET/HEAD). */
+function toRequest(req: IncomingMessage): Request {
+	const host = req.headers.host ?? "localhost";
+	const url = `http://${host}${req.url ?? "/"}`;
+
+	const method = req.method ?? "GET";
+	const hasBody = method !== "GET" && method !== "HEAD";
+
+	return new Request(url, {
+		method,
+		headers: req.headers as Record<string, string>,
+		// node streams are async-iterable, which `Request` accepts as a body source
+		body: hasBody ? (req as unknown as ReadableStream) : undefined,
+		// required by undici when streaming a request body
+		duplex: "half",
+	} as RequestInit);
+}
+
+/** pipe a whatwg `Response` back out through a node `ServerResponse`. */
+async function writeResponse(res: ServerResponse, response: Response): Promise<void> {
+	res.writeHead(response.status, Object.fromEntries(response.headers));
+	res.end(Buffer.from(await response.arrayBuffer()));
+}
+
+/**
+ * start a native node `http` server for a fetch-style handler (e.g. {@link panelHandler}).
+ * zero third-party deps — just `node:http`. on bun/deno use their built-in `serve` instead.
+ *
+ * ```ts
+ * import { panelHandler } from "@yaebal/panel";
+ * import { serve } from "@yaebal/panel/serve";
+ * serve(panelHandler(bot.api, store, { token }), { port: 8080 });
+ * ```
+ */
+export function serve(
+	handler: (request: Request) => Promise<Response> | Response,
+	options: ServeOptions,
+): Server {
+	const server = createServer((req, res) => {
+		Promise.resolve(handler(toRequest(req)))
+			.then((response) => writeResponse(res, response))
+			.catch(() => {
+				if (!res.headersSent) res.writeHead(500);
+				res.end("internal error");
+			});
+	});
+
+	server.listen(options.port, options.host, () => {
+		options.onListen?.({ port: options.port, host: options.host });
+	});
+
+	return server;
+}

package/src/sqlite.test.ts

@@ -0,0 +1,96 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+// `node:sqlite` (and therefore `SqlitePanelStore`) is only available on node 22.5+.
+// on older runtimes a static import of "./sqlite.js" throws ERR_UNKNOWN_BUILTIN_MODULE
+// at module-evaluation time, which would fail the whole file. import it lazily and
+// skip the suite when the builtin is missing instead.
+let SqlitePanelStore: typeof import("./sqlite.js").SqlitePanelStore | undefined;
+try {
+	({ SqlitePanelStore } = await import("./sqlite.js"));
+} catch {
+	SqlitePanelStore = undefined;
+}
+
+const skip = SqlitePanelStore ? false : "node:sqlite unavailable (requires node 22.5+)";
+// non-undefined alias for the test bodies (only reached when not skipped)
+const Store = SqlitePanelStore as NonNullable<typeof SqlitePanelStore>;
+
+test("SqlitePanelStore: records, lists newest-first, paginates and emits events", { skip }, () => {
+	const store = new Store(); // :memory:
+	const events: number[] = [];
+	store.subscribe((e) => events.push(e.chatId));
+
+	store.record({ id: 1, name: "@sam" }, { direction: "in", text: "hi", date: 10 });
+	store.record({ id: 2, name: "@lee" }, { direction: "in", text: "yo", date: 20 });
+	for (let i = 1; i <= 5; i++) {
+		store.record({ id: 1 }, { direction: "in", text: `m${i}`, date: 100 + i });
+	}
+
+	// chats sorted by last_date desc; name preserved across nameless records
+	const chats = store.chats();
+	assert.equal(chats[0]?.id, 1);
+	assert.equal(chats[0]?.name, "@sam");
+	assert.equal(chats[0]?.lastText, "m5");
+
+	// pagination
+	assert.deepEqual(
+		store.history(1, { limit: 2 }).map((m) => m.text),
+		["m4", "m5"],
+	);
+	assert.deepEqual(
+		store.history(1, { before: 103, limit: 2 }).map((m) => m.text),
+		["m1", "m2"],
+	);
+
+	assert.ok(events.length >= 2);
+	store.close();
+});
+
+test("SqlitePanelStore persists attachments and media_group_id round-trip", { skip }, () => {
+	const store = new Store();
+
+	store.record(
+		{ id: 1, name: "@u", firstName: "Uma", lastName: "Ray", username: "u" },
+		{
+			direction: "in",
+			text: "[photo]",
+			date: 1,
+			attachments: [{ type: "photo", fileId: "f1" }],
+			mediaGroupId: "G1",
+			keyboard: {
+				type: "inline",
+				rows: [[{ text: "Open", kind: "callback", callbackData: "open" }]],
+			},
+		},
+	);
+	store.record(
+		{ id: 1, name: "@u" },
+		{
+			direction: "in",
+			text: "button clicked: open",
+			date: 2,
+			event: { type: "callback", title: "button clicked", detail: "open", data: "open" },
+		},
+	);
+
+	const chat = store.chats()[0];
+	assert.equal(chat?.firstName, "Uma");
+	assert.equal(chat?.lastName, "Ray");
+	assert.equal(chat?.username, "u");
+	assert.equal(chat?.lastAttachmentType, undefined);
+	assert.equal(chat?.lastEventType, "callback");
+
+	const hist = store.history(1);
+	assert.deepEqual(hist[0]?.attachments, [{ type: "photo", fileId: "f1" }]);
+	assert.equal(hist[0]?.mediaGroupId, "G1");
+	assert.deepEqual(hist[0]?.keyboard, {
+		type: "inline",
+		rows: [[{ text: "Open", kind: "callback", callbackData: "open" }]],
+	});
+	// event message has no attachments/group keys
+	assert.equal(hist[1]?.attachments, undefined);
+	assert.equal(hist[1]?.mediaGroupId, undefined);
+	assert.equal(hist[1]?.event?.type, "callback");
+	store.close();
+});

package/src/sqlite.ts

@@ -0,0 +1,213 @@
+import { DatabaseSync } from "node:sqlite";
+import type {
+	HistoryOptions,
+	PanelAttachment,
+	PanelChat,
+	PanelChatRecord,
+	PanelEvent,
+	PanelKeyboard,
+	PanelMessage,
+	PanelMessageEvent,
+	PanelStore,
+} from "./index.js";
+
+function addColumn(db: DatabaseSync, table: string, definition: string): void {
+	try {
+		db.exec(`ALTER TABLE ${table} ADD COLUMN ${definition}`);
+	} catch {
+		// Existing sqlite stores from older panel versions simply already have the column.
+	}
+}
+
+/** options for {@link SqlitePanelStore}. */
+export interface SqlitePanelStoreOptions {
+	/** sqlite file path, or `":memory:"` (default). ignored when `db` is provided. */
+	path?: string;
+	/** bring your own `node:sqlite` database instead of opening one. */
+	db?: DatabaseSync;
+}
+
+/**
+ * a persistent {@link PanelStore} backed by node's built-in `node:sqlite` (node 22.5+).
+ * zero third-party deps. import from `@yaebal/panel/sqlite`.
+ *
+ * ```ts
+ * import { SqlitePanelStore } from "@yaebal/panel/sqlite";
+ * const store = new SqlitePanelStore({ path: "./panel.db" });
+ * ```
+ */
+export class SqlitePanelStore implements PanelStore {
+	#db: DatabaseSync;
+	#listeners = new Set<(event: PanelEvent) => void>();
+
+	constructor(options: SqlitePanelStoreOptions = {}) {
+		this.#db = options.db ?? new DatabaseSync(options.path ?? ":memory:");
+		this.#db.exec(`
+			CREATE TABLE IF NOT EXISTS panel_chats (
+				id              INTEGER PRIMARY KEY,
+				name            TEXT,
+				first_name      TEXT,
+				last_name       TEXT,
+				username        TEXT,
+				last_text       TEXT NOT NULL,
+				last_date       INTEGER NOT NULL,
+				last_attachment TEXT,
+				last_event      TEXT
+			);
+			CREATE TABLE IF NOT EXISTS panel_messages (
+				id          INTEGER PRIMARY KEY AUTOINCREMENT,
+				chat_id     INTEGER NOT NULL,
+				direction   TEXT NOT NULL,
+				text        TEXT NOT NULL,
+				date        INTEGER NOT NULL,
+				attachments TEXT,
+				media_group TEXT,
+				keyboard    TEXT,
+				event       TEXT
+			);
+			CREATE INDEX IF NOT EXISTS panel_messages_chat ON panel_messages (chat_id, date);
+		`);
+
+		addColumn(this.#db, "panel_chats", "first_name TEXT");
+		addColumn(this.#db, "panel_chats", "last_name TEXT");
+		addColumn(this.#db, "panel_chats", "username TEXT");
+		addColumn(this.#db, "panel_chats", "last_attachment TEXT");
+		addColumn(this.#db, "panel_chats", "last_event TEXT");
+		addColumn(this.#db, "panel_messages", "keyboard TEXT");
+		addColumn(this.#db, "panel_messages", "event TEXT");
+	}
+
+	record(chat: PanelChatRecord, message: PanelMessage): void {
+		this.#db
+			.prepare(
+				"INSERT INTO panel_messages (chat_id, direction, text, date, attachments, media_group, keyboard, event) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+			)
+			.run(
+				chat.id,
+				message.direction,
+				message.text,
+				message.date,
+				message.attachments ? JSON.stringify(message.attachments) : null,
+				message.mediaGroupId ?? null,
+				message.keyboard ? JSON.stringify(message.keyboard) : null,
+				message.event ? JSON.stringify(message.event) : null,
+			);
+
+		// keep the name when an outgoing message omits it; COALESCE the existing row's value
+		this.#db
+			.prepare(`
+				INSERT INTO panel_chats (
+					id, name, first_name, last_name, username, last_text, last_date, last_attachment, last_event
+				) VALUES (
+					:id, :name, :firstName, :lastName, :username, :text, :date, :lastAttachment, :lastEvent
+				)
+				ON CONFLICT(id) DO UPDATE SET
+					name = COALESCE(:name, panel_chats.name),
+					first_name = COALESCE(:firstName, panel_chats.first_name),
+					last_name = COALESCE(:lastName, panel_chats.last_name),
+					username = COALESCE(:username, panel_chats.username),
+					last_text = :text,
+					last_date = :date,
+					last_attachment = :lastAttachment,
+					last_event = :lastEvent
+			`)
+			.run({
+				id: chat.id,
+				name: chat.name ?? null,
+				firstName: chat.firstName ?? null,
+				lastName: chat.lastName ?? null,
+				username: chat.username ?? null,
+				text: message.text,
+				date: message.date,
+				lastAttachment: message.attachments?.[0]?.type ?? null,
+				lastEvent: message.event?.type ?? null,
+			});
+
+		// brand-new chat with no name → give it a stable fallback label
+		this.#db
+			.prepare("UPDATE panel_chats SET name = ? WHERE id = ? AND name IS NULL")
+			.run(`chat ${chat.id}`, chat.id);
+
+		for (const fn of this.#listeners) {
+			fn({ type: "record", chatId: chat.id, direction: message.direction });
+		}
+	}
+
+	chats(): PanelChat[] {
+		const rows = this.#db
+			.prepare(
+				"SELECT id, name, first_name, last_name, username, last_text, last_date, last_attachment, last_event FROM panel_chats ORDER BY last_date DESC",
+			)
+			.all() as Array<{
+			id: number;
+			name: string | null;
+			first_name: string | null;
+			last_name: string | null;
+			username: string | null;
+			last_text: string;
+			last_date: number;
+			last_attachment: PanelChat["lastAttachmentType"] | null;
+			last_event: PanelChat["lastEventType"] | null;
+		}>;
+
+		return rows.map((r) => {
+			const chat: PanelChat = {
+				id: r.id,
+				name: r.name ?? `chat ${r.id}`,
+				lastText: r.last_text,
+				lastDate: r.last_date,
+			};
+
+			if (r.first_name) chat.firstName = r.first_name;
+			if (r.last_name) chat.lastName = r.last_name;
+			if (r.username) chat.username = r.username;
+			if (r.last_attachment) chat.lastAttachmentType = r.last_attachment;
+			if (r.last_event) chat.lastEventType = r.last_event;
+
+			return chat;
+		});
+	}
+
+	history(chatId: number, options?: HistoryOptions): PanelMessage[] {
+		const before = options?.before ?? Number.MAX_SAFE_INTEGER;
+		const limit = options?.limit ?? -1; // sqlite: negative LIMIT = no limit
+
+		// grab the most recent `limit` rows older than `before`, then return ascending
+		const rows = this.#db
+			.prepare(`
+				SELECT direction, text, date, attachments, media_group, keyboard, event FROM panel_messages
+				WHERE chat_id = ? AND date < ?
+				ORDER BY date DESC, id DESC LIMIT ?
+			`)
+			.all(chatId, before, limit) as Array<{
+			direction: "in" | "out";
+			text: string;
+			date: number;
+			attachments: string | null;
+			media_group: string | null;
+			keyboard: string | null;
+			event: string | null;
+		}>;
+
+		return rows.reverse().map((r) => {
+			const msg: PanelMessage = { direction: r.direction, text: r.text, date: r.date };
+
+			if (r.attachments) msg.attachments = JSON.parse(r.attachments) as PanelAttachment[];
+			if (r.media_group) msg.mediaGroupId = r.media_group;
+			if (r.keyboard) msg.keyboard = JSON.parse(r.keyboard) as PanelKeyboard;
+			if (r.event) msg.event = JSON.parse(r.event) as PanelMessageEvent;
+
+			return msg;
+		});
+	}
+
+	subscribe(listener: (event: PanelEvent) => void): () => void {
+		this.#listeners.add(listener);
+		return () => this.#listeners.delete(listener);
+	}
+
+	/** close the underlying database (no-op if you passed your own `db`). */
+	close(): void {
+		this.#db.close();
+	}
+}