@prajwalshete/telegram-plugin 0.0.0-stage → 0.1.0

package/dist/routes/webhook.js

@@ -0,0 +1,147 @@
+import { Id } from "../contracts/common.js";
+import { timingSafeEqualStrings } from "../adapters/keyring.js";
+import { sql } from "../ports/sql.js";
+import { TelegramPluginError } from "../engine/errors.js";
+import { settle } from "../telegram/classify.js";
+import { isBotUsable, loadBot, webhookAad, withToken } from "../engine/bot-api.js";
+import { STATE_KEYS, getState, setState } from "../engine/state.js";
+import { metricCount } from "../engine/metrics.js";
+import { parseUpdate } from "../telegram/update.js";
+import { processUpdate, recordUpdate } from "../engine/dispatch/dispatcher.js";
+import { QUEUE_MARK } from "../engine/outbox/transport.js";
+import { actorMiddleware, errorHandler, idParam, requirePermission, runtimeMiddleware, schemaGuard } from "./http.js";
+import { Hono } from "hono";
+// src/routes/webhook.ts
+const SECRET_HEADER = "x-telegram-bot-api-secret-token";
+/** Telegram's webhook body limit is far below this; anything larger is not an update. */
+const MAX_BODY = 1e6;
+const ok = () => new Response(null, {
+	status: 200,
+	headers: { "cache-control": "private, no-store" }
+});
+/** The only non-2xx answer: the update could not be handed to the Queue, so Telegram must retry it. */
+const retryLater = () => new Response(null, {
+	status: 500,
+	headers: { "cache-control": "private, no-store" }
+});
+function webhookRoutes(deps) {
+	const app = new Hono();
+	app.onError(errorHandler(deps.errors));
+	app.use("/webhook/*", runtimeMiddleware(deps));
+	app.use("/dev/*", runtimeMiddleware(deps));
+	app.post("/webhook/:botId", async (c) => {
+		const rt = c.var.tg;
+		try {
+			const id = Id.safeParse(c.req.param("botId"));
+			if (!id.success) return ok();
+			const bot = await loadBot(rt, id.data);
+			if (!bot || !isBotUsable(bot) || bot.mode !== "webhook" || !bot.webhook_secret_enc) return ok();
+			const given = c.req.header(SECRET_HEADER) ?? "";
+			const secret = await rt.keyring.decrypt(bot.webhook_secret_enc, webhookAad(bot.id));
+			if (!await timingSafeEqualStrings(given, secret)) {
+				rt.log.warn("tg.webhook_rejected", { botId: bot.id });
+				metricCount(rt, "tg.webhook", 1, {
+					botId: bot.id,
+					outcome: "rejected"
+				});
+				return ok();
+			}
+			const text = await c.req.text();
+			if (text.length > MAX_BODY) return ok();
+			let json;
+			try {
+				json = JSON.parse(text);
+			} catch {
+				return ok();
+			}
+			const parsed = parseUpdate(json);
+			if (!parsed.ok) {
+				rt.log.warn("tg.update_invalid", {
+					botId: bot.id,
+					issues: parsed.issues.slice(0, 5)
+				});
+				return ok();
+			}
+			const now = rt.clock.now();
+			if (!await recordUpdate(rt, bot.id, parsed.update, now)) {
+				metricCount(rt, "tg.webhook", 1, {
+					botId: bot.id,
+					outcome: "duplicate"
+				});
+				return ok();
+			}
+			metricCount(rt, "tg.webhook", 1, {
+				botId: bot.id,
+				outcome: "accepted"
+			});
+			if (rt.queue) {
+				const msg = {
+					mark: QUEUE_MARK,
+					type: "update",
+					tenant: rt.tenant,
+					botId: bot.id,
+					update: json
+				};
+				try {
+					await rt.queue.send(msg);
+				} catch (e) {
+					rt.log.error("tg.webhook_queue_failed", {
+						botId: bot.id,
+						error: e instanceof Error ? e.name : "error"
+					});
+					metricCount(rt, "tg.webhook", 1, {
+						botId: bot.id,
+						outcome: "queue_failed"
+					});
+					if (await rt.db.run(sql`DELETE FROM tg_update WHERE tenant = ${rt.tenant} AND bot_id = ${bot.id}
+                  AND update_id = ${parsed.update.update_id} AND status = 'received'`).then(() => true, () => false)) return retryLater();
+					rt.log.error("tg.webhook_unrecord_failed", { botId: bot.id });
+					metricCount(rt, "tg.webhook", 1, {
+						botId: bot.id,
+						outcome: "queue_fallback"
+					});
+					rt.waitUntil(processUpdate(rt, bot, parsed.update));
+				}
+			} else rt.waitUntil(processUpdate(rt, bot, parsed.update));
+		} catch (e) {
+			rt.log.error("tg.webhook_error", { error: e instanceof Error ? e.name : "error" });
+		}
+		return ok();
+	});
+	app.post("/dev/poll/:botId", schemaGuard(deps), actorMiddleware, requirePermission("telegram.bots.manage"), async (c) => {
+		const rt = c.var.tg;
+		if (rt.appEnv === "production") throw new TelegramPluginError("not_found", "not available in production");
+		const bot = await loadBot(rt, idParam(c, "botId"));
+		if (!bot || !isBotUsable(bot)) throw new TelegramPluginError("not_found", "bot not found");
+		const offsetRaw = await getState(rt, STATE_KEYS.pollOffset(bot.id));
+		const offset = offsetRaw === null ? void 0 : Number(offsetRaw);
+		const r = await withToken(rt, bot, (api) => settle(api.getUpdates({
+			...offset === void 0 ? {} : { offset },
+			timeout: 0,
+			limit: 100
+		})));
+		if (r.outcome.kind !== "ok" || !r.value) throw new TelegramPluginError("webhook_failed", r.outcome.reason === "conflict" ? "a webhook is set; reset the bot to polling" : "getUpdates failed");
+		let received = 0;
+		let processed = 0;
+		let next = offset;
+		for (const raw of r.value) {
+			const parsed = parseUpdate(raw);
+			const updateId = parsed.ok ? parsed.update.update_id : parsed.updateId;
+			if (updateId !== null) next = Math.max(next ?? 0, updateId + 1);
+			if (!parsed.ok) continue;
+			received++;
+			if (await recordUpdate(rt, bot.id, parsed.update, rt.clock.now())) {
+				await processUpdate(rt, bot, parsed.update);
+				processed++;
+			}
+		}
+		if (next !== void 0 && next !== offset) await setState(rt, STATE_KEYS.pollOffset(bot.id), String(next), rt.clock.now());
+		return c.json({
+			received,
+			processed,
+			offset: next ?? null
+		});
+	});
+	return app;
+}
+export { webhookRoutes };

package/dist/schema/columns.js

@@ -0,0 +1,307 @@
+// src/schema/columns.ts
+const TABLE_COLUMNS = {
+	tg_bot: [
+		"id",
+		"tenant",
+		"name",
+		"tg_bot_id",
+		"username",
+		"token_enc",
+		"webhook_secret_enc",
+		"mode",
+		"status",
+		"status_detail",
+		"checked_at",
+		"default_locale",
+		"features_json",
+		"rate_per_sec",
+		"paused_until",
+		"drain_lease_until",
+		"drain_token",
+		"commands_synced_hash",
+		"created_by",
+		"created_at",
+		"updated_at",
+		"deleted_at"
+	],
+	tg_chat: [
+		"id",
+		"tenant",
+		"bot_id",
+		"chat_id",
+		"kind",
+		"title",
+		"username",
+		"user_id",
+		"audience_json",
+		"status",
+		"locale",
+		"timezone",
+		"topics_json",
+		"next_allowed_at",
+		"minute_window_start",
+		"minute_count",
+		"linked_by",
+		"linked_at",
+		"created_at",
+		"updated_at"
+	],
+	tg_link_code: [
+		"code_hash",
+		"tenant",
+		"bot_id",
+		"purpose",
+		"user_id",
+		"audience_json",
+		"expires_at",
+		"used_at",
+		"used_by_chat",
+		"created_by",
+		"created_at"
+	],
+	tg_destination: [
+		"id",
+		"tenant",
+		"name",
+		"slug",
+		"bot_id",
+		"chat_ref",
+		"message_thread_id",
+		"ai_allowed",
+		"created_by",
+		"created_at",
+		"updated_at",
+		"deleted_at"
+	],
+	tg_command: [
+		"tenant",
+		"bot_id",
+		"command",
+		"enabled",
+		"roles_json",
+		"aliases_json",
+		"description_json",
+		"show_in_menu",
+		"sort",
+		"updated_by",
+		"updated_at"
+	],
+	tg_template: [
+		"id",
+		"tenant",
+		"key",
+		"name",
+		"kind",
+		"provider",
+		"provider_params_json",
+		"body_json",
+		"format",
+		"report_json",
+		"buttons_json",
+		"options_json",
+		"version",
+		"created_by",
+		"created_at",
+		"updated_by",
+		"updated_at",
+		"deleted_at"
+	],
+	tg_template_version: [
+		"tenant",
+		"template_id",
+		"version",
+		"body_json",
+		"report_json",
+		"buttons_json",
+		"saved_by",
+		"saved_at"
+	],
+	tg_subscription: [
+		"tenant",
+		"chat_ref",
+		"topic",
+		"muted",
+		"quiet_json",
+		"updated_at"
+	],
+	tg_schedule: [
+		"id",
+		"tenant",
+		"name",
+		"rule_json",
+		"timezone",
+		"template_id",
+		"params_json",
+		"recipients_json",
+		"personalize",
+		"missed_policy",
+		"missed_grace_min",
+		"enabled",
+		"paused_until",
+		"next_run_at",
+		"claim_until",
+		"claim_token",
+		"last_run_at",
+		"last_status",
+		"created_by",
+		"created_at",
+		"updated_at",
+		"deleted_at"
+	],
+	tg_schedule_run: [
+		"id",
+		"tenant",
+		"schedule_id",
+		"slot_at",
+		"trigger",
+		"started_at",
+		"finished_at",
+		"status",
+		"deliveries",
+		"error",
+		"template_version"
+	],
+	tg_event_rule: [
+		"id",
+		"tenant",
+		"event",
+		"name",
+		"filter_json",
+		"template_id",
+		"recipients_json",
+		"throttle_json",
+		"enabled",
+		"created_by",
+		"created_at",
+		"updated_at",
+		"deleted_at"
+	],
+	tg_event: [
+		"id",
+		"tenant",
+		"event",
+		"payload_json",
+		"dedupe_key",
+		"occurred_at",
+		"status",
+		"attempts",
+		"claim_until",
+		"claim_token",
+		"processed_at",
+		"error"
+	],
+	tg_broadcast: [
+		"id",
+		"tenant",
+		"title",
+		"template_id",
+		"body_json",
+		"params_json",
+		"file_ref",
+		"recipients_json",
+		"status",
+		"stats_json",
+		"created_by",
+		"created_at",
+		"updated_at",
+		"sent_at",
+		"deleted_at"
+	],
+	tg_delivery: [
+		"id",
+		"tenant",
+		"bot_id",
+		"chat_ref",
+		"message_thread_id",
+		"source",
+		"source_id",
+		"kind",
+		"body_html",
+		"part",
+		"parts",
+		"file_ref",
+		"file_name",
+		"file_mime",
+		"reply_markup_json",
+		"options_json",
+		"render_json",
+		"target_message_id",
+		"dedupe_key",
+		"status",
+		"attempts",
+		"next_attempt_at",
+		"lease_until",
+		"lease_token",
+		"tg_message_id",
+		"error_code",
+		"error_detail",
+		"created_at",
+		"updated_at",
+		"sent_at"
+	],
+	tg_update: [
+		"tenant",
+		"bot_id",
+		"update_id",
+		"kind",
+		"chat_id",
+		"status",
+		"attempts",
+		"received_at",
+		"processed_at",
+		"error"
+	],
+	tg_action_token: [
+		"id",
+		"tenant",
+		"bot_id",
+		"action",
+		"params_json",
+		"chat_ref",
+		"user_id",
+		"single_use",
+		"confirmed_at",
+		"expires_at",
+		"used_at",
+		"result",
+		"created_at"
+	],
+	tg_dialog: [
+		"tenant",
+		"chat_ref",
+		"dialog",
+		"user_id",
+		"step",
+		"state_json",
+		"expires_at",
+		"started_at",
+		"updated_at"
+	],
+	tg_state: [
+		"tenant",
+		"key",
+		"value",
+		"updated_at"
+	],
+	tg_audit: [
+		"id",
+		"tenant",
+		"actor",
+		"entity",
+		"entity_id",
+		"action",
+		"diff_json",
+		"at"
+	]
+};
+/** Unique indexes the runtime relies on (ON CONFLICT targets); a DB without one is behind. */
+const UNIQUE_INDEXES = [
+	"tg_bot_tg_bot_uq",
+	"tg_chat_bot_chat_uq",
+	"tg_delivery_dedupe_uq",
+	"tg_destination_slug_uq",
+	"tg_event_dedupe_uq",
+	"tg_schedule_run_slot_uq",
+	"tg_template_key_uq"
+];
+export { TABLE_COLUMNS, UNIQUE_INDEXES };

package/dist/schema/ddl.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Plain SQL statements that create every plugin table and index, for hosts without Drizzle and for tests.
+ * `reference.sql` is `referenceSql()` (a test keeps them equal).
+ */
+export declare function referenceSqlStatements(): string[];
+/** `referenceSqlStatements()` as one file (what ships as `@prajwalshete/telegram-plugin/schema/reference.sql`). */
+export declare function referenceSql(): string;

package/dist/schema/ddl.js

@@ -0,0 +1,45 @@
+import { telegramTables } from "./tables.js";
+import { SQLiteDialect, getTableConfig } from "drizzle-orm/sqlite-core";
+// src/schema/ddl.ts
+function literal(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	if (typeof value === "string") return `'${value.replaceAll("'", "''")}'`;
+	throw new TypeError(`unsupported column default: ${String(value)}`);
+}
+const dialect = new SQLiteDialect();
+/** A partial index's `WHERE` as plain SQL (the plugin only uses parameter-free predicates). */
+function whereSql(where) {
+	if (!where) return "";
+	const q = dialect.sqlToQuery(where, "indexes");
+	if (q.params.length > 0) throw new TypeError("index WHERE must not have parameters");
+	return ` WHERE ${q.sql}`;
+}
+function tableDdl(table) {
+	const cfg = getTableConfig(table);
+	const lines = cfg.columns.map((c) => {
+		let line = `  ${c.name} ${c.getSQLType().toUpperCase()}`;
+		if (c.primary) line += " PRIMARY KEY";
+		if (c.notNull) line += " NOT NULL";
+		if (c.default !== void 0) line += ` DEFAULT ${literal(c.default)}`;
+		return line;
+	});
+	for (const pk of cfg.primaryKeys) lines.push(`  PRIMARY KEY (${pk.columns.map((c) => c.name).join(", ")})`);
+	const out = [`CREATE TABLE IF NOT EXISTS ${cfg.name} (\n${lines.join(",\n")}\n);`];
+	for (const ix of cfg.indexes) {
+		const cols = ix.config.columns.map((c) => "name" in c ? c.name : "?").join(", ");
+		out.push(`CREATE ${ix.config.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${ix.config.name} ON ${cfg.name} (${cols})${whereSql(ix.config.where)};`);
+	}
+	return out;
+}
+/**
+* Plain SQL statements that create every plugin table and index, for hosts without Drizzle and for tests.
+* `reference.sql` is `referenceSql()` (a test keeps them equal).
+*/
+function referenceSqlStatements() {
+	return Object.values(telegramTables()).flatMap((t) => tableDdl(t));
+}
+/** `referenceSqlStatements()` as one file (what ships as `@prajwalshete/telegram-plugin/schema/reference.sql`). */
+function referenceSql() {
+	return `-- cf-telegram-plugin reference schema. Generated from telegramTables(); do not edit by hand.\n\n${referenceSqlStatements().join("\n\n")}\n`;
+}
+export { referenceSql, referenceSqlStatements };