Checkmate/server/src/service/bufferService.ts

import type { Check } from "@/domain/checks/check.type.js";
import type { GeoCheck } from "@/domain/geo-checks/geo-check.type.js";
import type { IGeoChecksService } from "../domain/geo-checks/geo-check.service.js";
import type { ILogger } from "@/utils/logger.js";
import type { ISettingsService } from "@/domain/app-settings/app-settings.service.js";
import { ICheckService } from "../domain/checks/check.service.js";
const SERVICE_NAME = "BufferService";

export interface IBufferService {
	addToBuffer(check: Check): void;
	addGeoCheckToBuffer(geoCheck: GeoCheck): void;
	scheduleNextFlush(): void;
	flushBuffer(): Promise<void>;
	flushGeoBuffer(): Promise<void>;
}

export class BufferService implements IBufferService {
	static SERVICE_NAME = SERVICE_NAME;
	private BUFFER_TIMEOUT: number;
	private logger: ILogger;
	private SERVICE_NAME: string;
	private buffer: Check[];
	private geoBuffer: GeoCheck[];
	private bufferTimer: NodeJS.Timeout | null = null;
	private checksService: ICheckService;
	private geoChecksService: IGeoChecksService;

	constructor(logger: ILogger, checkService: ICheckService, geoChecksService: IGeoChecksService, settingsService: ISettingsService) {
		this.BUFFER_TIMEOUT = settingsService.getSettings().nodeEnv === "development" ? 1000 : 1000 * 60 * 1; // 1 minute
		this.logger = logger;
		this.checksService = checkService;
		this.geoChecksService = geoChecksService;
		this.SERVICE_NAME = SERVICE_NAME;
		this.buffer = [];
		this.geoBuffer = [];
		this.scheduleNextFlush();
		this.logger.info({
			message: `Buffer service initialized, flushing every ${this.BUFFER_TIMEOUT / 1000}s`,
			service: this.SERVICE_NAME,
			method: "constructor",
		});
	}

	get serviceName() {
		return BufferService.SERVICE_NAME;
	}

	addToBuffer(check: Check) {
		try {
			this.buffer.push(check);
		} catch (error: unknown) {
			this.logger.error({
				message: error instanceof Error ? error.message : "Unknown error",
				service: this.SERVICE_NAME,
				method: "addToBuffer",
				stack: error instanceof Error ? error.stack : undefined,
			});
		}
	}

	addGeoCheckToBuffer(geoCheck: GeoCheck) {
		try {
			this.geoBuffer.push(geoCheck);
		} catch (error: unknown) {
			this.logger.error({
				message: error instanceof Error ? error.message : "Unknown error",
				service: this.SERVICE_NAME,
				method: "addGeoCheckToBuffer",
				stack: error instanceof Error ? error.stack : undefined,
			});
		}
	}

	scheduleNextFlush() {
		if (this.bufferTimer) {
			clearTimeout(this.bufferTimer);
		}
		this.bufferTimer = setTimeout(async () => {
			try {
				await this.flushBuffer();
				await this.flushGeoBuffer();
			} catch (error: unknown) {
				this.logger.error({
					message: error instanceof Error ? error.message : "Unknown error",
					service: this.SERVICE_NAME,
					method: "scheduleNextFlush",
					stack: error instanceof Error ? error.stack : undefined,
				});
			} finally {
				// Schedule the next flush only after the current one completes
				this.scheduleNextFlush();
			}
		}, this.BUFFER_TIMEOUT);
	}
	async flushBuffer() {
		try {
			if (this.buffer.length > 0) {
				this.logger.debug({
					message: `Flushing ${this.buffer.length} checks to database`,
					service: this.SERVICE_NAME,
					method: "flushBuffer",
				});
				await this.checksService.createChecks(this.buffer);
				this.buffer = [];
			}
		} catch (error: unknown) {
			this.logger.error({
				message: error instanceof Error ? error.message : "Unknown error",
				service: this.SERVICE_NAME,
				method: "flushBuffer",
				stack: error instanceof Error ? error.stack : undefined,
			});
			// Clear buffer even on error to prevent infinite retry loops
			this.buffer = [];
		}
	}

	async flushGeoBuffer() {
		try {
			if (this.geoBuffer.length > 0) {
				this.logger.debug({
					message: `Flushing ${this.geoBuffer.length} geo checks to database`,
					service: this.SERVICE_NAME,
					method: "flushGeoBuffer",
				});
				await this.geoChecksService.createGeoChecks(this.geoBuffer);
				this.geoBuffer = [];
			}
		} catch (error: unknown) {
			this.logger.error({
				message: error instanceof Error ? error.message : "Unknown error",
				service: this.SERVICE_NAME,
				method: "flushGeoBuffer",
				stack: error instanceof Error ? error.stack : undefined,
			});
			// Clear buffer even on error to prevent infinite retry loops
			this.geoBuffer = [];
		}
	}
}