@prajwalshete/telegram-plugin 0.0.0-stage → 0.1.0

package/dist/engine/content/render.js

@@ -0,0 +1,138 @@
+import { decodeEntities } from "../../core/html/escape.js";
+import { splitMessage } from "../../core/split/split.js";
+import { parseTemplate } from "../../core/template/parse.js";
+import { validateTemplate } from "../../core/template/validate.js";
+import { renderTemplate } from "../../core/template/render.js";
+import { TelegramPluginError } from "../errors.js";
+// src/engine/content/render.ts
+/** The variant for the first candidate that has one (exact tag, then its language), else the first variant. */
+function pickVariant(body, candidates) {
+	for (const c of candidates) {
+		if (!c) continue;
+		if (Object.hasOwn(body, c)) return {
+			locale: c,
+			source: body[c]
+		};
+		const lang = c.split("-")[0];
+		if (lang && Object.hasOwn(body, lang)) return {
+			locale: lang,
+			source: body[lang]
+		};
+	}
+	const first = Object.entries(body)[0];
+	return first ? {
+		locale: first[0],
+		source: first[1]
+	} : null;
+}
+/** `text` templates: literal `& < >` outside `{{…}}` are escaped, so no tag survives. */
+function escapeTextSource(src) {
+	let out = "";
+	let i = 0;
+	while (i < src.length) {
+		const open = src.indexOf("{{", i);
+		const end = open === -1 ? src.length : open;
+		out += src.slice(i, end).replace(/[&<>]/g, (c) => c === "&" ? "&amp;" : c === "<" ? "&lt;" : "&gt;");
+		if (open === -1) break;
+		const close = src.indexOf("}}", open + 2);
+		if (close === -1) {
+			out += src.slice(open);
+			break;
+		}
+		out += src.slice(open, close + 2);
+		i = close + 2;
+	}
+	return out;
+}
+const astCache = /* @__PURE__ */ new Map();
+/** Parses a template source (cached per isolate; sources are small and repeat across a fan-out). */
+function parseSource(source, format) {
+	const key = `${format}\u0000${source}`;
+	let hit = astCache.get(key);
+	if (!hit) {
+		hit = parseTemplate(format === "text" ? escapeTextSource(source) : source);
+		if (astCache.size > 500) astCache.clear();
+		astCache.set(key, hit);
+	}
+	return hit;
+}
+function toTemplateError(e, locale) {
+	const out = {
+		line: e.line,
+		column: e.column,
+		message: e.message
+	};
+	if (locale) out.locale = locale;
+	return out;
+}
+/** `variable_unknown` only → `template_variable_unknown`; anything else → `template_invalid`. Both carry `errors[]`. */
+function templateProblem(errors) {
+	const onlyVars = errors.length > 0 && errors.every((e) => e.code === "variable_unknown");
+	const list = errors.slice(0, 50).map((e) => toTemplateError(e, e.locale));
+	return new TelegramPluginError(onlyVars ? "template_variable_unknown" : "template_invalid", onlyVars ? "the template uses variables the provider does not declare" : "the template is not valid", { extensions: { errors: list } });
+}
+/**
+* Checks every locale variant: syntax, then variables against the provider schema (when given) and filters.
+* Returns the problems with their locale; empty means valid.
+*/
+function checkBody(body, format, opts = {}) {
+	const out = [];
+	for (const [locale, source] of Object.entries(body)) {
+		const { ast, errors } = parseSource(source, format);
+		if (errors.length > 0) {
+			for (const e of errors) out.push({
+				...e,
+				locale
+			});
+			continue;
+		}
+		for (const e of validateTemplate(ast, opts)) out.push({
+			...e,
+			locale
+		});
+	}
+	return out;
+}
+/** Renders one locale variant. Throws `template_invalid` for a source that does not parse. */
+function renderBody(rt, input) {
+	const variant = pickVariant(input.body, [...input.locales, rt.i18n.defaultLocale]);
+	if (!variant) throw new TelegramPluginError("template_invalid", "the template has no body");
+	const { ast, errors } = parseSource(variant.source, input.format);
+	if (errors.length > 0) throw templateProblem(errors.map((e) => ({
+		...e,
+		locale: variant.locale
+	})));
+	const r = renderTemplate(ast, {
+		vars: input.vars,
+		locale: variant.locale,
+		tz: input.tz,
+		currency: rt.settings.currency,
+		minorDigits: rt.settings.minorUnitDigits,
+		filters: rt.filters
+	});
+	const html = r.html.trim();
+	return {
+		locale: variant.locale,
+		html,
+		parts: input.noSplit || html === "" ? [] : splitMessage(html),
+		warnings: r.warnings.map((w) => toTemplateError(w, variant.locale))
+	};
+}
+/** Renders a one-line template (file names, URLs) to plain text: entities decoded, tags dropped. */
+function renderInline(rt, source, vars, ctx) {
+	const { ast, errors } = parseSource(source, "text");
+	if (errors.length > 0) throw templateProblem(errors.map((e) => ({
+		...e,
+		locale: ctx.locale
+	})));
+	const r = renderTemplate(ast, {
+		vars,
+		locale: ctx.locale,
+		tz: ctx.tz,
+		currency: rt.settings.currency,
+		minorDigits: rt.settings.minorUnitDigits,
+		filters: rt.filters
+	});
+	return decodeEntities(r.html);
+}
+export { checkBody, escapeTextSource, parseSource, pickVariant, renderBody, renderInline, templateProblem, toTemplateError };

package/dist/engine/content/reply.js

@@ -0,0 +1,156 @@
+import { escapeHtml } from "../../core/html/escape.js";
+import { TelegramPluginError, featureDisabled } from "../errors.js";
+import { renderBody } from "./render.js";
+import { buildButtons } from "./buttons.js";
+import { fileUrl, storeReportFile } from "./report-files.js";
+import { buildReport, templateData } from "../../services/reports.js";
+import { requireTemplateByKey, templateModel } from "./template-rows.js";
+import { openSource } from "../../services/send.js";
+// src/engine/content/reply.ts
+function options(t, opts) {
+	return {
+		...t,
+		...opts?.silent ? { silent: true } : {},
+		...opts?.protectContent ? { protectContent: true } : {}
+	};
+}
+async function tooLarge(ctx, ref, name, caption) {
+	const { rt } = ctx;
+	rt.log.warn("tg.file_too_large", {
+		botId: ctx.bot.id,
+		code: "file_too_large"
+	});
+	const locale = await ctx.locale();
+	const url = await fileUrl(rt, ref);
+	const link = url ? `\n${rt.i18n.t(locale, "bot.report.download")} <a href="${escapeHtml(url)}">${escapeHtml(name)}</a>` : "";
+	await ctx.replyDelivery({
+		kind: "text",
+		html: [caption, `${rt.i18n.t(locale, "bot.report.too_large")}${link}`].filter(Boolean).join("\n\n")
+	});
+}
+/** Renders a report for the chat's audience, stores the file and replies with it as a document. */
+async function replyReport(ctx, t, actor, params, opts) {
+	const { rt } = ctx;
+	const info = rt.describe(actor);
+	const tz = ctx.chat?.timezone ?? rt.settings.timezone;
+	const built = await buildReport(rt, {
+		template: t,
+		actor,
+		params,
+		locales: [
+			ctx.chat?.locale,
+			info.locale,
+			ctx.from?.language_code,
+			ctx.bot.default_locale
+		],
+		tz,
+		format: opts?.format,
+		now: ctx.now
+	});
+	const stored = await storeReportFile(rt, built.file, {
+		template: t.key,
+		source_kind: "command"
+	});
+	if (stored.size !== null && stored.size > 52428800) {
+		await tooLarge(ctx, stored.ref, stored.name, built.caption.html);
+		return;
+	}
+	await ctx.replyDelivery({
+		kind: "document",
+		html: built.caption.html,
+		file: {
+			ref: stored.ref,
+			name: stored.name,
+			mime: stored.mime
+		},
+		options: options(t.options, opts),
+		render: {
+			template: t.key,
+			templateVersion: t.version
+		}
+	});
+}
+async function replyTemplate(ctx, key, params, opts) {
+	const { rt } = ctx;
+	if (!rt.features.templates) throw featureDisabled("templates");
+	const t = templateModel(await requireTemplateByKey(rt, key));
+	const actor = await ctx.actor();
+	if (actor === null) {
+		await ctx.reply(await ctx.t("bot.error.not_linked"));
+		return;
+	}
+	if (t.kind === "report") {
+		await replyReport(ctx, t, actor, params, opts);
+		return;
+	}
+	const info = rt.describe(actor);
+	const locales = [
+		ctx.chat?.locale,
+		info.locale,
+		ctx.from?.language_code,
+		ctx.bot.default_locale
+	];
+	const tz = ctx.chat?.timezone ?? rt.settings.timezone;
+	const vars = await templateData(rt, {
+		template: t,
+		actor,
+		params,
+		tz,
+		now: ctx.now,
+		locale: rt.i18n.pick(...locales)
+	});
+	const body = renderBody(rt, {
+		body: t.body,
+		format: t.format,
+		vars,
+		locales,
+		tz
+	});
+	if (body.parts.length === 0) return;
+	const chat = ctx.chat;
+	const buttons = await buildButtons(rt, opts?.buttons ?? t.buttons, {
+		vars,
+		locale: body.locale,
+		tz,
+		botId: ctx.bot.id,
+		chatRef: chat?.id ?? null,
+		userId: chat?.kind === "private" ? chat.user_id : null,
+		now: ctx.now
+	});
+	await ctx.replyDelivery({
+		kind: "text",
+		html: body.html,
+		replyMarkup: buttons.markup,
+		options: options(t.options, opts),
+		sql: buttons.sql,
+		render: {
+			template: t.key,
+			templateVersion: t.version
+		}
+	});
+}
+/** Sends a stored file (a registered file source, or the files port) the chat's actor may read. */
+async function replyFile(ctx, file, opts) {
+	const actor = await ctx.actor();
+	if (actor === null) throw new TelegramPluginError("forbidden", "the chat is not linked");
+	const source = file.source ?? "files";
+	const opened = await openSource(ctx.rt, actor, source, file.ref);
+	await opened.body.cancel().catch(() => {});
+	const caption = file.caption ?? "";
+	if (opened.size !== null && opened.size > 52428800) {
+		await tooLarge(ctx, opened.ref, opened.name, caption);
+		return;
+	}
+	await ctx.replyDelivery({
+		kind: "document",
+		html: caption,
+		file: {
+			ref: opened.ref,
+			name: opened.name,
+			mime: opened.mime,
+			...source === "files" ? {} : { source }
+		},
+		options: options({}, opts)
+	});
+}
+export { replyFile, replyReport, replyTemplate };

package/dist/engine/content/report-files.js

@@ -0,0 +1,78 @@
+import { TelegramPluginError, featureDisabled } from "../errors.js";
+import { renderInline } from "./render.js";
+import { csvRenderer } from "../../renderers/csv.js";
+import { browserRunPdf, isBrowserRunBinding } from "../../renderers/html.js";
+// src/engine/content/report-files.ts
+const MAX_UPLOAD_BYTES = 52428800;
+const builtinCsv = csvRenderer();
+/** The renderer for a format: `ports.renderers` first, then built-in CSV, then Browser Rendering for PDF. */
+function rendererFor(rt, format) {
+	if (!rt.features.reports) throw featureDisabled("reports");
+	const allowed = rt.features.reportRenderers;
+	if (allowed.length > 0 && !allowed.includes(format)) throw new TelegramPluginError("renderer_unavailable", `renderer "${format}" is not enabled`);
+	const host = rt.renderers.find((r) => r.format === format);
+	if (host) return host;
+	if (format === "csv") return builtinCsv;
+	if (format === "pdf" && isBrowserRunBinding(rt.browser)) return browserRunPdf(rt.browser);
+	throw new TelegramPluginError("renderer_unavailable", `no renderer for "${format}"`);
+}
+function reportFormatOf(template, override) {
+	return override ?? template.report?.renderer ?? "csv";
+}
+function cleanName(name) {
+	const n = [...name].map((ch) => ch === "/" || ch === "\\" || ch.charCodeAt(0) < 32 ? "_" : ch).join("").trim();
+	return n === "" ? "report" : n.slice(0, 128);
+}
+/** Renders the report file (not stored). */
+async function renderReportFile(rt, input) {
+	const format = reportFormatOf(input.template, input.format);
+	const renderer = rendererFor(rt, format);
+	const base = input.template.report?.fileName ?? input.template.key;
+	const fileName = cleanName(renderInline(rt, base, input.vars, {
+		locale: input.locale,
+		tz: input.tz
+	}));
+	const named = /\.[a-z0-9]{2,4}$/i.test(fileName) ? fileName.replace(/\.[a-z0-9]{2,4}$/i, `.${format}`) : `${fileName}.${format}`;
+	const title = input.template.layout?.title ? input.template.layout.title[input.locale] ?? Object.values(input.template.layout.title)[0] : void 0;
+	return renderer.render({
+		data: input.vars,
+		fileName: named,
+		locale: input.locale,
+		timezone: input.tz,
+		layout: input.template.report?.layout,
+		html: input.html,
+		title: title ?? named.replace(/\.[a-z0-9]+$/i, ""),
+		currency: rt.settings.currency,
+		minorDigits: rt.settings.minorUnitDigits,
+		labels: {
+			yes: rt.i18n.plain(input.locale, "bot.report.yes"),
+			no: rt.i18n.plain(input.locale, "bot.report.no")
+		}
+	}, rt.env);
+}
+/** Stores a rendered file through the files port. */
+async function storeReportFile(rt, file, tags) {
+	if (!rt.files) throw new TelegramPluginError("renderer_unavailable", "report files need ports.files or env.files (R2)");
+	const stored = await rt.files.put({
+		name: file.name,
+		mime: file.mime,
+		body: file.body,
+		tags: {
+			source: "telegram",
+			...tags
+		}
+	}, null);
+	return {
+		...stored,
+		size: stored.size ?? file.size ?? null
+	};
+}
+/** A link to a stored file in the app, when the files port can make one. */
+async function fileUrl(rt, ref) {
+	try {
+		return await rt.files?.url?.(ref) ?? null;
+	} catch {
+		return null;
+	}
+}
+export { MAX_UPLOAD_BYTES, fileUrl, renderReportFile, rendererFor, reportFormatOf, storeReportFile };

package/dist/engine/content/template-rows.js

@@ -0,0 +1,74 @@
+import { LocalizedText } from "../../contracts/common.js";
+import { ButtonRows, ReportLayout, ReportSpec, TemplateOptions } from "../../contracts/templates.js";
+import { sql } from "../../ports/sql.js";
+import { TelegramPluginError } from "../errors.js";
+import { parseJson, parseObject } from "../rows.js";
+// src/engine/content/template-rows.ts
+/** Parses a row; invalid JSON columns fall back to empty / null values (never throws). */
+function templateModel(r) {
+	const report = parseJson(r.report_json, ReportSpec.nullable(), null);
+	return {
+		id: r.id,
+		key: r.key,
+		name: r.name,
+		kind: r.kind === "report" ? "report" : "message",
+		provider: r.provider,
+		providerParams: parseObject(r.provider_params_json),
+		body: parseJson(r.body_json, LocalizedText, {}),
+		format: r.format === "text" ? "text" : "html",
+		report,
+		layout: report?.layout ? ReportLayout.safeParse(report.layout).data ?? null : null,
+		buttons: parseJson(r.buttons_json, ButtonRows.nullable(), null),
+		options: parseJson(r.options_json, TemplateOptions, {}),
+		version: r.version
+	};
+}
+/** The admin API DTO of a row. */
+function templateDto(r) {
+	const m = templateModel(r);
+	return {
+		id: m.id,
+		key: m.key,
+		name: m.name,
+		kind: m.kind,
+		provider: m.provider,
+		providerParams: m.providerParams,
+		body: m.body,
+		format: m.format,
+		report: m.report,
+		buttons: m.buttons,
+		options: m.options,
+		version: m.version,
+		updatedBy: r.updated_by,
+		updatedAt: r.updated_at
+	};
+}
+function templateVersionDto(r) {
+	return {
+		templateId: r.template_id,
+		version: r.version,
+		body: parseJson(r.body_json, LocalizedText, {}),
+		report: parseJson(r.report_json, ReportSpec.nullable(), null),
+		buttons: parseJson(r.buttons_json, ButtonRows.nullable(), null),
+		savedBy: r.saved_by,
+		savedAt: r.saved_at
+	};
+}
+async function templateById(rt, id) {
+	return rt.db.first(sql`SELECT * FROM tg_template WHERE tenant = ${rt.tenant} AND id = ${id} AND deleted_at IS NULL`);
+}
+/** A live (not deleted) template of this tenant by key, or null. */
+async function templateByKey(rt, key) {
+	return rt.db.first(sql`SELECT * FROM tg_template WHERE tenant = ${rt.tenant} AND key = ${key} AND deleted_at IS NULL`);
+}
+async function requireTemplate(rt, id) {
+	const row = await templateById(rt, id);
+	if (!row) throw new TelegramPluginError("not_found", "template not found");
+	return row;
+}
+async function requireTemplateByKey(rt, key) {
+	const row = await templateByKey(rt, key);
+	if (!row) throw new TelegramPluginError("not_found", `template "${key}" not found`);
+	return row;
+}
+export { requireTemplate, requireTemplateByKey, templateById, templateByKey, templateDto, templateModel, templateVersionDto };

package/dist/engine/dialogs/dialog.d.ts

@@ -0,0 +1,2 @@
+/** `callback_data` prefix of dialog choice buttons (`d:<step>:<index>`); host buttons must not use it. */
+export declare const DIALOG_PREFIX = "d:";