@yaebal/panel 0.0.2 → 0.0.5

package/src/serve.ts

@@ -1,4 +1,4 @@
-import { type IncomingMessage, type Server, type ServerResponse, createServer } from "node:http";
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 
 /** options for the node {@link serve} helper. */
 export interface ServeOptions {

package/src/sqlite.test.ts

@@ -1,9 +1,23 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { SqlitePanelStore } from "./sqlite.js";
 
-test("SqlitePanelStore: records, lists newest-first, paginates and emits events", () => {
-	const store = new SqlitePanelStore(); // :memory:
+// `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));
 
@@ -33,26 +47,50 @@ test("SqlitePanelStore: records, lists newest-first, paginates and emits events"
 	store.close();
 });
 
-test("SqlitePanelStore persists attachments and media_group_id round-trip", () => {
-	const store = new SqlitePanelStore();
+test("SqlitePanelStore persists attachments and media_group_id round-trip", { skip }, () => {
+	const store = new Store();
 
 	store.record(
-		{ id: 1, name: "@u" },
+		{ 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" },
 		},
 	);
-	store.record({ id: 1, name: "@u" }, { direction: "out", text: "thanks", date: 2 });
+
+	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");
-	// plain text message has no attachments/group keys
+	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

@@ -3,11 +3,22 @@ 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. */
@@ -33,10 +44,15 @@ export class SqlitePanelStore implements PanelStore {
 		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,
-				last_text TEXT NOT NULL,
-				last_date INTEGER NOT NULL
+				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,
@@ -45,16 +61,26 @@ export class SqlitePanelStore implements PanelStore {
 				text        TEXT NOT NULL,
 				date        INTEGER NOT NULL,
 				attachments TEXT,
-				media_group 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: { id: number; name?: string }, message: PanelMessage): void {
+	record(chat: PanelChatRecord, message: PanelMessage): void {
 		this.#db
 			.prepare(
-				"INSERT INTO panel_messages (chat_id, direction, text, date, attachments, media_group) VALUES (?, ?, ?, ?, ?, ?)",
+				"INSERT INTO panel_messages (chat_id, direction, text, date, attachments, media_group, keyboard, event) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
 			)
 			.run(
 				chat.id,
@@ -63,18 +89,39 @@ export class SqlitePanelStore implements PanelStore {
 				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, last_text, last_date) VALUES (:id, :name, :text, :date)
+				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_date = :date,
+					last_attachment = :lastAttachment,
+					last_event = :lastEvent
 			`)
-			.run({ id: chat.id, name: chat.name ?? null, text: message.text, date: message.date });
+			.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
@@ -88,15 +135,37 @@ export class SqlitePanelStore implements PanelStore {
 
 	chats(): PanelChat[] {
 		const rows = this.#db
-			.prepare("SELECT id, name, last_text, last_date FROM panel_chats ORDER BY last_date DESC")
-			.all() as Array<{ id: number; name: string | null; last_text: string; last_date: number }>;
-
-		return rows.map((r) => ({
-			id: r.id,
-			name: r.name ?? `chat ${r.id}`,
-			lastText: r.last_text,
-			lastDate: r.last_date,
-		}));
+			.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[] {
@@ -106,7 +175,7 @@ export class SqlitePanelStore implements PanelStore {
 		// grab the most recent `limit` rows older than `before`, then return ascending
 		const rows = this.#db
 			.prepare(`
-				SELECT direction, text, date, attachments, media_group FROM panel_messages
+				SELECT direction, text, date, attachments, media_group, keyboard, event FROM panel_messages
 				WHERE chat_id = ? AND date < ?
 				ORDER BY date DESC, id DESC LIMIT ?
 			`)
@@ -116,13 +185,17 @@ export class SqlitePanelStore implements PanelStore {
 			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;
 		});