nyx-bot-client 0.0.2

package/cron/actions-server.ts

@@ -0,0 +1,87 @@
+// Cron: @reboot
+
+import dotenv from "dotenv";
+import { Kysely, MysqlDialect } from "kysely";
+import { createPool } from "mysql2";
+import { createClient } from "redis";
+import z from "zod";
+import type { NyxAction } from "../utils/actions";
+import * as methods from "../utils/methods";
+
+const envScheme = z.object({
+	BROKER_MYSQL_USER: z.string().nonempty(),
+	BROKER_MYSQL_NAME: z.string().nonempty(),
+	BROKER_MYSQL_PASS: z.string().nonempty(),
+	BROKER_MYSQL_HOST: z.string().nonempty(),
+});
+
+const env: z.infer<typeof envScheme> = envScheme.parse(
+	dotenv.config({
+		path: `${__dirname}/../.env`,
+		quiet: true,
+	}).parsed,
+);
+
+const mysql = createPool({
+	user: env.BROKER_MYSQL_USER,
+	database: env.BROKER_MYSQL_NAME,
+	password: env.BROKER_MYSQL_PASS,
+	host: env.BROKER_MYSQL_HOST,
+	maxIdle: 2,
+	idleTimeout: 120_000,
+});
+
+const db = new Kysely<{
+	actions: {
+		id?: number;
+		params: NyxAction;
+		date: number;
+	};
+}>({
+	dialect: new MysqlDialect({
+		pool: mysql,
+	}),
+});
+
+const redis = createClient();
+await redis.connect();
+
+redis.subscribe("nyx-action", async (input) => {
+	try {
+		const data: NyxAction = JSON.parse(input);
+
+		await db
+			.insertInto("actions")
+			.values({
+				params: JSON.stringify(data) as any,
+				date: data.date,
+			})
+			.execute();
+	} catch (e) {
+		console.error(e);
+	}
+});
+
+setInterval(async () => {
+	const tasks = await db
+		.selectFrom("actions")
+		.selectAll()
+		.where("date", "<=", Math.trunc(Date.now() / 1000))
+		.execute();
+
+	if (tasks.length > 0) {
+		await db
+			.deleteFrom("actions")
+			.where("date", "<=", Math.trunc(Date.now() / 1000))
+			.execute();
+
+		for (const task of tasks) {
+			const params: NyxAction = JSON.parse(task.params as any);
+
+			methods[params.type]({
+				bot_token: params.bot_token,
+				...params.params,
+			} as any);
+		}
+	}
+}, 60_000);

package/index.ts

@@ -0,0 +1,9 @@
+export type * from "./@types/index.ts";
+export * from "./nyx-client.ts";
+export type * from "./types.d.ts";
+export * from "./utils/actions.ts";
+export * from "./utils/api.ts";
+export * from "./utils/enum.ts";
+export * from "./utils/helpers.ts";
+export * from "./utils/methods.ts";
+export * from "./utils/table.ts";

package/nyx-client.ts

@@ -0,0 +1,133 @@
+import { createClient } from "redis";
+import { z } from "zod";
+import type { EventTypes } from "./@types";
+import type {
+	BotConfig,
+	BotInjections,
+	BotPipelines,
+	SubscribeCallback,
+} from "./types";
+import { NyxResponse } from "./utils/enum";
+import { encodeHTMLEntities } from "./utils/helpers";
+import { sendMessage } from "./utils/methods";
+
+type NyxConfig = {
+	botConfig: BotConfig;
+	pipelines: BotPipelines;
+	injections?: BotInjections;
+	onStartup?: () => Promise<void>;
+	onShutdown?: () => Promise<void>;
+	benchmark?: boolean;
+};
+
+class NyxClient {
+	public botConfig: BotConfig | undefined;
+	public pipelines: BotPipelines = {};
+	public subscriptions: { [key: string]: SubscribeCallback } = {};
+	public injections: BotInjections | undefined;
+	public benchmark: boolean | undefined;
+
+	private redis = createClient();
+
+	public async initialize(config: NyxConfig) {
+		this.botConfig = z
+			.object({
+				username: z.string().nonempty(),
+				token: z.string().nonempty(),
+				api: z.string().default("https://api.telegram.org"),
+				admin_id: z.coerce.number().optional(),
+			})
+			.parse(config.botConfig);
+		this.pipelines = config.pipelines;
+		this.injections = config.injections;
+		this.benchmark = config.benchmark;
+
+		await this.redis.connect();
+		this.redis.subscribe(
+			this.botConfig.username,
+			this.handleUpdateRequest.bind(this),
+		);
+
+		config.onStartup?.();
+
+		process.on("SIGTERM", async () => {
+			await config.onShutdown?.();
+			process.exit(0);
+		});
+	}
+
+	public async handleUpdateRequest(update: string | object) {
+		if (this.benchmark) {
+			console.time("benchmark-request");
+		}
+
+		const inject = await this.injections?.();
+
+		try {
+			const data = typeof update === "string" ? JSON.parse(update) : update;
+
+			if ("update_id" in data) {
+				delete data.update_id;
+				const update_type: keyof EventTypes = Object.keys(data)[0] as any;
+
+				if (!this.pipelines[update_type]) return;
+
+				for (const handler of this.pipelines[update_type]) {
+					const result = await handler(data[update_type], inject?.injections);
+
+					if (result === NyxResponse.Finish) {
+						break;
+					}
+				}
+			} else if ("type" in data && "data" in data) {
+				for (const type in this.subscriptions) {
+					if (data.type === type) {
+						this.subscriptions[type]!(data.data);
+						break;
+					}
+				}
+			}
+		} catch (e: any) {
+			console.error(e);
+
+			if (this.botConfig?.admin_id) {
+				sendMessage({
+					chat_id: this.botConfig?.admin_id,
+					text: `🚫 <b>Error Reporting</b>\n\n<pre>${encodeHTMLEntities(e.stack || e.toString())}</pre>`,
+				});
+			}
+		} finally {
+			await inject?.onFinish?.();
+		}
+
+		if (this.benchmark) {
+			console.timeEnd("benchmark-request");
+
+			console.log(
+				"Memory Usage:",
+				Object.fromEntries(
+					Object.entries(process.memoryUsage()).map(([k, v]) => [
+						k,
+						`${Math.trunc((v / 1024 / 1024) * 100) / 100}MB`,
+					]),
+				),
+			);
+
+			console.log("------------------------------");
+		}
+	}
+
+	public subscribe(event: string, callback: SubscribeCallback) {
+		this.subscriptions[event] = callback;
+	}
+
+	public unsubscribe(event: string) {
+		if (event in this.subscriptions) {
+			delete this.subscriptions[event];
+		}
+	}
+}
+
+const client = new NyxClient();
+
+export default client;

package/package.json

@@ -0,0 +1,22 @@
+{
+	"name": "nyx-bot-client",
+	"version": "0.0.2",
+	"module": "index.ts",
+	"type": "module",
+	"devDependencies": {
+		"@types/bun": "latest"
+	},
+	"peerDependencies": {
+		"typescript": "^5"
+	},
+	"dependencies": {
+		"@biomejs/biome": "^2.2.4",
+		"@types/node": "^24.5.2",
+		"dotenv": "^17.2.2",
+		"kysely": "^0.28.7",
+		"mysql2": "^3.15.0",
+		"redis": "^5.8.2",
+		"ts-debounce": "^4.0.0",
+		"zod": "^4.1.9"
+	}
+}

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+	"compilerOptions": {
+		// Environment setup & latest features
+		"lib": ["ESNext"],
+		"target": "ESNext",
+		"module": "ESNext",
+		"moduleDetection": "force",
+		"jsx": "react-jsx",
+		"allowJs": true,
+
+		// Bundler mode
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"noEmit": true,
+
+		// Best practices
+		"strict": true,
+		"skipLibCheck": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedIndexedAccess": true,
+
+		// Some stricter flags (disabled by default)
+		"noUnusedLocals": false,
+		"noUnusedParameters": false,
+		"noPropertyAccessFromIndexSignature": false
+	}
+}

package/types.d.ts

@@ -0,0 +1,35 @@
+import type { Kysely } from "kysely";
+import type { Connection, Pool } from "mysql2";
+import type { RedisClientType } from "redis";
+import type { EventTypes } from "./@types";
+import type { NyxResponse } from "./utils/enum";
+
+export type BotConfig = {
+	username: string;
+	token: string;
+	api?: string;
+	admin_id?: number;
+};
+
+export type BotPipeline<K extends keyof EventTypes, T> = (
+	data: EventTypes[K],
+	injections?: Injections<T>,
+) => Promise<NyxResponse>;
+
+export type BotPipelines = {
+	[K in keyof EventTypes]?: BotPipeline<K>[];
+};
+
+export type SubscribeCallback = (params: any) => void;
+
+export type BotInjections = () => Promise<{
+	injections: Injections;
+	onFinish?: () => Promise<void>;
+}>;
+
+export type Injections<T> = {
+	mysql?: Connection | Pool;
+	redis?: RedisClientType;
+	db?: Kysely<T>;
+	[key: string]: any;
+};

package/utils/actions.ts

@@ -0,0 +1,30 @@
+import { createClient, type RedisClientType } from "redis";
+import type * as methods from "./methods.ts";
+
+type MethodName = keyof typeof methods;
+
+type ParamsOf<T extends MethodName> = T extends MethodName
+	? Parameters<(typeof methods)[T]>[0]
+	: never;
+
+export type NyxAction<T extends MethodName = MethodName> = {
+	type: T;
+	params: ParamsOf<T>;
+	date: number;
+	bot_token: string;
+	bot_api_server?: string;
+	redis?: RedisClientType;
+};
+
+export const actionBroker = async <T extends MethodName>(
+	action: NyxAction<T>,
+) => {
+	if (action.redis) {
+		await action.redis.publish("nyx-action", JSON.stringify(action));
+	} else {
+		const redis = createClient();
+		await redis.connect();
+		await redis.publish("nyx-action", JSON.stringify(action));
+		await redis.close();
+	}
+};

package/utils/api.ts

@@ -0,0 +1,27 @@
+import client from "../nyx-client";
+
+export const requestTelegramAPI = async (
+	method: string,
+	params: any,
+): Promise<any> => {
+	const token = params.bot_token ?? client.botConfig!.token;
+	const api =
+		params.bot_api_server ??
+		client.botConfig?.api ??
+		"https://api.telegram.org";
+	const request_method = params.request_method ?? "POST";
+
+	delete params.bot_token;
+	delete params.bot_api_server;
+	delete params.request_method;
+
+	const request = await fetch(`${api}/bot${token}/${method}`, {
+		method: request_method,
+		body: JSON.stringify(params),
+		headers: {
+			"Content-Type": "application/json",
+		},
+	});
+
+	return await request.json();
+};

package/utils/enum.ts

@@ -0,0 +1,5 @@
+export const NyxResponse = {
+	Ok: 200,
+	Finish: 299,
+	Error: 500,
+};

package/utils/helpers.ts

@@ -0,0 +1,71 @@
+import {
+	getChatMember,
+	type getChatMemberParams,
+	type methodParams,
+} from "./methods";
+
+export const isUserMemberOf = async (params: getChatMemberParams) => {
+	const result = await getChatMember(params);
+
+	if (result.ok) {
+		return !["left", "kicked"].includes(result.result.status);
+	}
+
+	return false;
+};
+
+export const isUserAdminOf = async (params: getChatMemberParams) => {
+	const result = await getChatMember(params);
+
+	if (result.ok) {
+		return ["creator", "administrator"].includes(result.result.status);
+	}
+
+	return false;
+};
+
+export const mentionUserEntity = (text: string, user_id: number) =>
+	`<a href='tg://user?id=${user_id}'>${text}</a>`;
+
+export type SponsorChat = {
+	chat_id: number;
+	username?: string;
+	title?: string;
+};
+
+export type getRemainingSponsorChatsParams = {
+	user_id: number;
+	sponsors: SponsorChat[];
+} & methodParams;
+
+export const getRemainingSponsorChats = async (
+	params: getRemainingSponsorChatsParams,
+) => {
+	const result = await Promise.all(
+		params.sponsors.map(
+			(sponsor) =>
+				new Promise<[boolean, SponsorChat]>((resolve) => {
+					isUserMemberOf({
+						chat_id: sponsor.chat_id,
+						user_id: params.user_id,
+						bot_api_server: params.bot_api_server,
+						bot_token: params.bot_token,
+					})
+						.then((result) => {
+							resolve([result, sponsor]);
+						})
+						.catch(() => {
+							resolve([false, sponsor]);
+						});
+				}),
+		),
+	);
+
+	return result.filter(([joined]) => !joined).map(([, sponsor]) => sponsor);
+};
+
+export const encodeHTMLEntities = (str: string): string => {
+	return str.replace(/[\u00A0-\u9999<>&"'`]/g, (char) => {
+		return `&#${char.charCodeAt(0)};`;
+	});
+};