@xbibzlibrary/telebibz 0.1.2 → 0.1.3

package/dist-cjs/src/storage/storage.js

@@ -1,6 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryStorage = void 0;
+exports.MongoStorage = exports.SqlStorage = exports.RedisStorage = exports.JsonFileStorage = exports.MemoryStorage = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+function expiration(ttlMs) {
+    if (ttlMs === undefined)
+        return undefined;
+    if (!Number.isFinite(ttlMs) || ttlMs < 0)
+        throw new RangeError("ttlMs must be a finite non-negative number");
+    return Date.now() + ttlMs;
+}
 class MemoryStorage {
     valuesMap = new Map();
     locks = new Map();
@@ -15,10 +24,8 @@ class MemoryStorage {
         return entry.value;
     }
     async set(key, value, options = {}) {
-        const entry = { value };
-        if (options.ttlMs !== undefined)
-            entry.expiresAt = Date.now() + options.ttlMs;
-        this.valuesMap.set(key, entry);
+        const expiresAt = expiration(options.ttlMs);
+        this.valuesMap.set(key, expiresAt === undefined ? { value } : { value, expiresAt });
     }
     async delete(key) { return this.valuesMap.delete(key); }
     async has(key) { return (await this.get(key)) !== undefined; }
@@ -52,3 +59,126 @@ class MemoryStorage {
     }
 }
 exports.MemoryStorage = MemoryStorage;
+class JsonFileStorage {
+    filePath;
+    memory = new MemoryStorage();
+    ready;
+    writeChain = Promise.resolve();
+    constructor(filePath) {
+        this.filePath = filePath;
+        this.ready = this.load();
+    }
+    async load() {
+        try {
+            const raw = await (0, promises_1.readFile)(this.filePath, "utf8");
+            const values = JSON.parse(raw);
+            for (const [key, entry] of Object.entries(values))
+                await this.memory.set(key, entry.value, entry.expiresAt === undefined ? {} : { ttlMs: Math.max(0, entry.expiresAt - Date.now()) });
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    async persist() {
+        await this.ready;
+        this.writeChain = this.writeChain.then(async () => {
+            const output = {};
+            for await (const [key, value] of this.memory.entries())
+                output[key] = { value };
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(this.filePath), { recursive: true });
+            const temporary = `${this.filePath}.${process.pid}.tmp`;
+            await (0, promises_1.writeFile)(temporary, JSON.stringify(output, null, 2), "utf8");
+            await (0, promises_1.rename)(temporary, this.filePath);
+        });
+        await this.writeChain;
+    }
+    async get(key) { await this.ready; return this.memory.get(key); }
+    async set(key, value, options) { await this.ready; await this.memory.set(key, value, options); await this.persist(); }
+    async delete(key) { await this.ready; const deleted = await this.memory.delete(key); if (deleted)
+        await this.persist(); return deleted; }
+    async has(key) { await this.ready; return this.memory.has(key); }
+    async clear() { await this.ready; await this.memory.clear(); await this.persist(); }
+    async *keys() { await this.ready; yield* this.memory.keys(); }
+    async *values() { await this.ready; yield* this.memory.values(); }
+    async *entries() { await this.ready; yield* this.memory.entries(); }
+    async update(key, updater, options) { await this.ready; const result = await this.memory.update(key, updater, options); await this.persist(); return result; }
+}
+exports.JsonFileStorage = JsonFileStorage;
+class RedisStorage {
+    client;
+    prefix;
+    constructor(client, prefix = "telebibz:") {
+        this.client = client;
+        this.prefix = prefix;
+    }
+    key(key) { return `${this.prefix}${key}`; }
+    unkey(key) { return key.slice(this.prefix.length); }
+    async get(key) { const value = await this.client.get(this.key(key)); return value === null ? undefined : JSON.parse(value); }
+    async set(key, value, options = {}) { const ttl = options.ttlMs; const redisOptions = ttl === undefined ? {} : ttl >= 1000 ? { PX: Math.max(1, Math.floor(ttl)) } : { PX: Math.max(1, Math.floor(ttl)) }; await this.client.set(this.key(key), JSON.stringify(value), redisOptions); }
+    async delete(key) { return (await this.client.del(this.key(key))) > 0; }
+    async has(key) { return (await this.client.exists(this.key(key))) > 0; }
+    async clear() { const keys = await this.client.keys(`${this.prefix}*`); if (keys.length)
+        await Promise.all(keys.map((key) => this.client.del(key))); }
+    async *keys() { for (const key of await this.client.keys(`${this.prefix}*`))
+        yield this.unkey(key); }
+    async *values() { for await (const [, value] of this.entries())
+        yield value; }
+    async *entries() { for await (const key of this.keys()) {
+        const value = await this.get(key);
+        if (value !== undefined)
+            yield [key, value];
+    } }
+    async update(key, updater, options) { const value = await updater(await this.get(key)); await this.set(key, value, options); return value; }
+}
+exports.RedisStorage = RedisStorage;
+class SqlStorage {
+    driver;
+    constructor(driver) {
+        this.driver = driver;
+    }
+    async get(key) { return this.driver.get(key); }
+    async set(key, value, options = {}) { await this.driver.set(key, value, expiration(options.ttlMs)); }
+    async delete(key) { return this.driver.delete(key); }
+    async has(key) { return this.driver.has(key); }
+    async clear() { return this.driver.clear(); }
+    async *keys() { for (const [key] of await this.driver.entries())
+        yield key; }
+    async *values() { for (const [, value] of await this.driver.entries())
+        yield value; }
+    async *entries() { for (const [key, value, expiresAt] of await this.driver.entries()) {
+        if (expiresAt !== undefined && expiresAt <= Date.now()) {
+            await this.driver.delete(key);
+            continue;
+        }
+        yield [key, value];
+    } }
+    async update(key, updater, options) { const value = await updater(await this.get(key)); await this.set(key, value, options); return value; }
+}
+exports.SqlStorage = SqlStorage;
+class MongoStorage {
+    collection;
+    constructor(collection) {
+        this.collection = collection;
+    }
+    async get(key) { const document = await this.collection.findOne({ key }); if (!document || (document.expiresAt !== undefined && document.expiresAt <= Date.now()))
+        return undefined; return document.value; }
+    async set(key, value, options = {}) {
+        const expiresAt = expiration(options.ttlMs);
+        const document = expiresAt === undefined ? { key, value } : { key, value, expiresAt };
+        await this.collection.replaceOne({ key }, document, { upsert: true });
+    }
+    async delete(key) { return (await this.collection.deleteOne({ key })).deletedCount === 1; }
+    async has(key) { return (await this.get(key)) !== undefined; }
+    async clear() { await this.collection.deleteMany({}); }
+    async *keys() { for (const document of await this.collection.find({}).toArray())
+        if (document.expiresAt === undefined || document.expiresAt > Date.now())
+            yield document.key; }
+    async *values() { for await (const [, value] of this.entries())
+        yield value; }
+    async *entries() { for (const document of await this.collection.find({}).toArray())
+        if (document.expiresAt === undefined || document.expiresAt > Date.now())
+            yield [document.key, document.value]; }
+    async update(key, updater, options) { const value = await updater(await this.get(key)); await this.set(key, value, options); return value; }
+}
+exports.MongoStorage = MongoStorage;

package/dist-cjs/src/telegram-features.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentsClient = void 0;
+exports.parseWebAppInitData = parseWebAppInitData;
+exports.validateWebAppInitData = validateWebAppInitData;
+const node_crypto_1 = require("node:crypto");
+function parseWebAppInitData(initData) {
+    const params = new URLSearchParams(initData);
+    const hash = params.get("hash");
+    if (!hash)
+        throw new Error("Web App init data is missing hash");
+    const data = {};
+    for (const [key, value] of params.entries())
+        if (key !== "hash")
+            data[key] = value;
+    const authDateRaw = data.auth_date;
+    const authDate = authDateRaw === undefined ? undefined : Number(authDateRaw);
+    if (authDate !== undefined && (!Number.isInteger(authDate) || authDate <= 0))
+        throw new Error("Web App init data has an invalid auth_date");
+    const parseObject = (key) => {
+        const value = data[key];
+        if (value === undefined)
+            return undefined;
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            throw new Error(`Web App init data field ${key} is not valid JSON`);
+        }
+    };
+    const result = { raw: initData, hash, data };
+    if (authDate !== undefined)
+        result.authDate = authDate;
+    const user = parseObject("user");
+    const receiver = parseObject("receiver");
+    const chat = parseObject("chat");
+    if (user !== undefined)
+        result.user = user;
+    if (receiver !== undefined)
+        result.receiver = receiver;
+    if (chat !== undefined)
+        result.chat = chat;
+    return result;
+}
+function validateWebAppInitData(initData, botToken, maxAgeSeconds = 86_400, nowMs = Date.now()) {
+    if (!botToken)
+        throw new Error("botToken is required");
+    if (!Number.isFinite(maxAgeSeconds) || maxAgeSeconds < 0)
+        throw new RangeError("maxAgeSeconds must be non-negative");
+    const parsed = parseWebAppInitData(initData);
+    const checkString = Object.entries(parsed.data).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}=${value}`).join("\n");
+    const secret = (0, node_crypto_1.createHmac)("sha256", "WebAppData").update(botToken).digest();
+    const expected = (0, node_crypto_1.createHmac)("sha256", secret).update(checkString).digest("hex");
+    const actual = Buffer.from(parsed.hash, "hex");
+    const expectedBuffer = Buffer.from(expected, "hex");
+    if (actual.length !== expectedBuffer.length || !(0, node_crypto_1.timingSafeEqual)(actual, expectedBuffer))
+        throw new Error("Web App init data signature is invalid");
+    if (parsed.authDate !== undefined && nowMs / 1000 - parsed.authDate > maxAgeSeconds)
+        throw new Error("Web App init data has expired");
+    return parsed;
+}
+class PaymentsClient {
+    api;
+    constructor(api) {
+        this.api = api;
+    }
+    createInvoiceLink(payload) { return this.api.call("createInvoiceLink", payload); }
+    sendInvoice(payload) { return this.api.call("sendInvoice", payload); }
+    answerPreCheckoutQuery(payload) { return this.api.call("answerPreCheckoutQuery", payload); }
+    answerWebAppQuery(payload) { return this.api.call("answerWebAppQuery", payload); }
+    getStarTransactions(payload = {}) { return this.api.call("getStarTransactions", payload); }
+    refundStarPayment(payload) { return this.api.call("refundStarPayment", payload); }
+}
+exports.PaymentsClient = PaymentsClient;

package/dist-cjs/src/testing.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockTransport = void 0;
 exports.createMockUpdate = createMockUpdate;
+exports.createMockCallbackUpdate = createMockCallbackUpdate;
 exports.createTestBot = createTestBot;
 exports.createMockContext = createMockContext;
 const bot_js_1 = require("./core/bot.js");
@@ -14,5 +15,21 @@ class MockTransport {
 }
 exports.MockTransport = MockTransport;
 function createMockUpdate(overrides = {}) { return { update_id: 1, message: { message_id: 1, date: Date.now(), chat: { id: 1, type: "private" }, from: { id: 2, is_bot: false, first_name: "Test" }, text: "/start" }, ...overrides }; }
+function createMockCallbackUpdate(overrides = {}) {
+    const base = createMockUpdate();
+    delete base.message;
+    return {
+        ...base,
+        update_id: 2,
+        callback_query: {
+            id: "callback-1",
+            from: { id: 2, is_bot: false, first_name: "Test" },
+            message: { message_id: 10, date: Date.now(), chat: { id: 1, type: "private" }, text: "Choose" },
+            chat_instance: "chat-instance",
+            data: "action",
+        },
+        ...overrides,
+    };
+}
 function createTestBot() { const transport = new MockTransport(); transport.respond("getMe", { ok: true, result: { id: 99, is_bot: true, first_name: "TestBot", username: "test_bot" } }); return { bot: new bot_js_1.Bot({ token: "123456:TEST_TOKEN", transport }), transport }; }
 function createMockContext(bot, update = createMockUpdate()) { return new context_js_1.Context({ update, api: bot.api, session: {}, services: {} }); }