nyx-bot-client 0.0.2

package/utils/objects.ts

@@ -0,0 +1,37 @@
+export function createReactiveObject(obj: any, onChange: () => void): any {
+	let scheduled = false;
+
+	const scheduleUpdate = () => {
+		if (!scheduled) {
+			scheduled = true;
+			queueMicrotask(() => {
+				scheduled = false;
+				onChange();
+			});
+		}
+	};
+
+	const handler: ProxyHandler<any> = {
+		get(target, prop, receiver) {
+			const value = Reflect.get(target, prop, receiver);
+			if (typeof value === "object" && value !== null) {
+				return createReactiveObject(value, onChange);
+			}
+			return value;
+		},
+
+		set(target, prop, value, receiver) {
+			const result = Reflect.set(target, prop, value, receiver);
+			scheduleUpdate();
+			return result;
+		},
+
+		deleteProperty(target, prop) {
+			const result = Reflect.deleteProperty(target, prop);
+			scheduleUpdate();
+			return result;
+		},
+	};
+
+	return new Proxy(obj, handler);
+}

package/utils/table.ts

@@ -0,0 +1,72 @@
+import type { RedisClientType } from "redis";
+import { debounce } from "ts-debounce";
+import { createReactiveObject } from "./objects";
+
+type NyxTableOptions<T> = {
+	persistenceDebounceMillis?: number;
+	onInternalUpdate?: (table: T) => Promise<void>;
+	onExternalUpdate?: (table: T) => Promise<void>;
+};
+
+class NyxTable<T> {
+	private uid: string;
+	private pid: string;
+	private options: NyxTableOptions<T> | undefined;
+	private schema: T;
+	private redis: RedisClientType;
+	private key: string;
+	private channel: string;
+	private handleUpdate: (() => void) | undefined;
+
+	public table: T;
+
+	constructor(
+		uid: string,
+		schema: T,
+		redis: RedisClientType,
+		options?: NyxTableOptions<T>,
+	) {
+		this.uid = uid;
+		this.key = `NyxTable-${this.uid}`;
+		this.channel = `channel-${this.key}`;
+		this.pid = `${Date.now().toString(36)}-${process.pid.toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+		this.options = options;
+		this.schema = schema;
+		this.redis = redis;
+
+		this.table = undefined as any;
+		this.assignTable(this.schema);
+
+		this.initialize();
+	}
+
+	private assignTable(table: any) {
+		this.table = undefined as any;
+		this.table = createReactiveObject(table, () => this.handleUpdate?.());
+	}
+
+	private async initialize() {
+		if (await this.redis.exists(this.key)) {
+			this.assignTable(JSON.parse((await this.redis.get(this.key))!));
+		} else {
+			await this.redis.set(this.key, JSON.stringify(this.table));
+		}
+
+		this.handleUpdate = debounce(async () => {
+			await this.redis.set(this.key, JSON.stringify(this.table));
+			await this.redis.publish(this.channel, this.pid);
+			await this.options?.onInternalUpdate?.(this.table);
+		}, this.options?.persistenceDebounceMillis ?? 1_000);
+
+		const redisSub = this.redis.duplicate();
+		await redisSub.connect();
+		redisSub.subscribe(this.channel, async (pid) => {
+			if (pid !== this.pid) {
+				this.assignTable(JSON.parse((await this.redis.get(this.key))!));
+				await this.options?.onExternalUpdate?.(this.table);
+			}
+		});
+	}
+}
+
+export default NyxTable;