chore: release v0.0.14

.gitignore

@@ -3,6 +3,7 @@ out
 dist
 tmp
 lib
+data
 
 .vscode
 .env
@@ -22,4 +23,5 @@ src/update.ini
 !eslint.config.js
 
 coverage
-*.tsbuildinfo
+*.tsbuildinfo
+.DS_Store

apps/api-master/environment.d.ts

@@ -0,0 +1,10 @@
+declare module "ip-location-api" {
+	export function lookup(ip: string): Promise<{
+		latitude: number;
+		longitude: number;
+		country: string;
+	} | null>;
+
+	export function updateDb(options: { fields?: string[]; dataDir?: string; tmpDataDir?: string }): Promise<void>;
+	export function reload(options: { fields?: string[]; dataDir?: string; tmpDataDir?: string }): Promise<void>;
+}

apps/api-master/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@premid/api-master",
 	"type": "module",
-	"version": "0.0.4",
+	"version": "0.0.24",
 	"private": true,
 	"description": "PreMiD's api master",
 	"license": "MPL-2.0",
@@ -14,12 +14,17 @@
 		"dev": "node --watch --env-file .env --enable-source-maps ."
 	},
 	"dependencies": {
-		"@discordjs/rest": "^2.3.0",
 		"@envelop/sentry": "^9.0.0",
+		"@opentelemetry/api": "^1.9.0",
+		"@opentelemetry/exporter-prometheus": "^0.52.1",
+		"@opentelemetry/node": "^0.24.0",
 		"@sentry/node": "^8.17.0",
 		"cron": "^3.1.7",
 		"debug": "^4.3.6",
-		"ioredis": "^5.3.2"
+		"ioredis": "^5.3.2",
+		"ip-location-api": "^1.0.0",
+		"ky": "^1.7.2",
+		"p-limit": "^6.1.0"
 	},
 	"devDependencies": {
 		"@types/debug": "^4.1.12"

apps/api-master/src/functions/clearOldSessions.ts

@@ -1,48 +1,100 @@
-import { REST } from "@discordjs/rest";
+import pLimit from "p-limit";
+import ky, { HTTPError, TimeoutError } from "ky";
 import { mainLog, redis } from "../index.js";
 
+let inProgress = false;
 export async function clearOldSessions() {
-	const sessionKeys = await redis.keys("pmd:session:*");
-	const now = Math.floor(Date.now() / 1000);
-
-	if (sessionKeys.length === 0) {
-		mainLog("No sessions to clear");
+	if (inProgress) {
+		mainLog("Session cleanup already in progress");
 		return;
 	}
 
-	mainLog(`Checking ${sessionKeys.length} sessions`);
-
+	inProgress = true;
+	const now = Date.now();
+	const pattern = "pmd-api.sessions.*";
+	let cursor = "0";
+	let totalSessions = 0;
 	let cleared = 0;
-	for (const key of sessionKeys) {
-		const session = await redis.hgetall(key);
+	const batchSize = 100;
+	let keysToDelete: string[] = [];
 
-		if (!session.t || !session.u) {
-			await redis.del(key);
-			cleared++;
-			continue;
+	mainLog("Starting session cleanup");
+
+	const limit = pLimit(100); // Create a limit of 100 concurrent operations
+
+	do {
+		const [newCursor, keys] = await redis.scan(cursor, "MATCH", pattern, "COUNT", 1000); //* Use SCAN with COUNT for memory efficiency
+
+		cursor = newCursor;
+		totalSessions += keys.length;
+
+		const deletePromises: Promise<string>[] = [];
+
+		for (const key of keys) {
+			const session = await redis.hgetall(key) as unknown as {
+				token: string;
+				session: string;
+				lastUpdated: number;
+			};
+
+			if (now - session.lastUpdated < 30000)
+				continue;
+
+			deletePromises.push(limit(() => deleteSession(session, key)));
 		}
 
-		//* If the session is younger than 30 seconds, skip it
-		if (now - Number(session.u) < 30)
-			continue;
+		const results = await Promise.allSettled(deletePromises);
+		results.forEach((result) => {
+			if (result.status === "fulfilled" && result.value) {
+				keysToDelete.push(result.value);
+				cleared++;
+			}
+		});
 
-		//* Delete the session
-		try {
-			const discord = new REST({ version: "10", authPrefix: "Bearer" });
-			discord.setToken(session.t);
-			await discord.post("/users/@me/headless-sessions/delete", {
-				body: {
-					token: key.split(":")[2], // Extract session token from key
-				},
-			});
-		}
-		catch (error) {
-			mainLog(`Failed to delete session: %O`, error);
+		if (keysToDelete.length >= batchSize) {
+			await redis.del(...keysToDelete);
+			keysToDelete = [];
 		}
+	} while (cursor !== "0");
 
-		cleared++;
-		await redis.del(key);
+	if (keysToDelete.length > 0) {
+		await redis.del(...keysToDelete);
 	}
 
-	mainLog(`Cleared ${cleared} sessions`);
+	if (totalSessions === 0) {
+		mainLog("No sessions to clear");
+	}
+	else {
+		mainLog(`Checked ${totalSessions} sessions, cleared ${cleared}`);
+	}
+
+	inProgress = false;
+}
+
+async function deleteSession(session: { token: string; session: string }, key: string): Promise<string> {
+	try {
+		await ky.post("https://discord.com/api/v10/users/@me/headless-sessions/delete", {
+			json: {
+				token: session.session,
+			},
+			headers: {
+				Authorization: `Bearer ${session.token}`,
+			},
+			retry: 3,
+			timeout: 5000,
+		});
+	}
+	catch (error) {
+		if (error instanceof TimeoutError) {
+			mainLog(`Session deletion aborted due to timeout for key ${key}`);
+		}
+		else if (error instanceof HTTPError) {
+			mainLog(`Failed to delete session for key ${key}: [${error.name}] ${error.message} ${JSON.stringify(await error.response.json())}`);
+		}
+		else {
+			mainLog(`Failed to delete session for key ${key}: Unknown error`);
+		}
+	}
+
+	return key;
 }

apps/api-master/src/functions/clearableGaugeMetric.ts

@@ -0,0 +1,83 @@
+import type { ServerResponse } from "node:http";
+import type { Attributes } from "@opentelemetry/api";
+import { ValueType, diag } from "@opentelemetry/api";
+import type { PrometheusExporter, PrometheusSerializer } from "@opentelemetry/exporter-prometheus";
+import { AggregationTemporality, DataPointType, type GaugeMetricData, InstrumentType } from "@opentelemetry/sdk-metrics";
+
+const registeredMetrics = new Map<string, ClearableGaugeMetric>();
+
+//* Custom gauge metric class
+export class ClearableGaugeMetric {
+	private data: Map<string, { value: number; attributes: Attributes }>;
+	private name: string;
+	private description: string;
+
+	constructor(name: string, description: string) {
+		this.data = new Map();
+		this.name = name;
+		this.description = description;
+		registeredMetrics.set(name, this);
+	}
+
+	set(key: string, value: number, attributes: Attributes) {
+		this.data.set(key, { value, attributes });
+	}
+
+	clear() {
+		this.data.clear();
+	}
+
+	toMetricData(): GaugeMetricData {
+		return {
+			descriptor: {
+				name: this.name,
+				description: this.description,
+				unit: "",
+				type: InstrumentType.GAUGE,
+				valueType: ValueType.INT,
+			},
+			dataPointType: DataPointType.GAUGE,
+			dataPoints: Array.from(this.data.values()).map(({ value, attributes }) => ({
+				value,
+				attributes,
+				startTime: [0, 0],
+				endTime: [0, 0],
+			})),
+			aggregationTemporality: AggregationTemporality.CUMULATIVE,
+		};
+	}
+
+	get hasData() {
+		return this.data.size > 0;
+	}
+}
+
+export function updatePrometheusMetrics(prometheusExporter: PrometheusExporter) {
+	// @ts-expect-error We are modifying a private method
+	prometheusExporter._exportMetrics = function (this: PrometheusExporter, response: ServerResponse) {
+		response.statusCode = 200;
+		response.setHeader("content-type", "text/plain");
+		this.collect().then(
+			(collectionResult) => {
+				const { resourceMetrics, errors } = collectionResult;
+				if (errors.length) {
+					diag.error(
+						"PrometheusExporter: metrics collection errors",
+						...errors,
+					);
+				}
+
+				for (const metric of registeredMetrics.values()) {
+					if (metric.hasData) {
+						resourceMetrics.scopeMetrics[0]!.metrics.push(metric.toMetricData());
+					}
+				}
+
+				response.end((this as unknown as { _serializer: PrometheusSerializer })._serializer.serialize(resourceMetrics));
+			},
+			(err) => {
+				response.end(`# failed to export metrics: ${err}`);
+			},
+		);
+	}.bind(prometheusExporter);
+}

apps/api-master/src/functions/lookupIp.ts

@@ -0,0 +1,46 @@
+import { join } from "node:path";
+import process from "node:process";
+import { lookup, reload, updateDb } from "ip-location-api";
+import { mainLog } from "../index.js";
+
+const fields = ["latitude", "longitude", "country"];
+
+const dataDir = join(process.cwd(), "data");
+const tmpDataDir = join(process.cwd(), "tmp");
+
+let initialized = false;
+
+export async function lookupIp(ip: string): Promise<{ latitude: number; longitude: number; country: string } | undefined> {
+	if (!initialized) {
+		reloadIpLocationApi();
+		return undefined;
+	}
+	try {
+		return await lookup(ip) ?? undefined;
+	}
+	catch {
+		return undefined;
+	}
+}
+
+let reloading: Promise<void> | undefined;
+let log: debug.Debugger | undefined;
+
+export async function reloadIpLocationApi() {
+	log ??= mainLog.extend("IP-Location-API");
+
+	if (reloading)
+		return reloading;
+
+	reloading = new Promise((resolve, reject) => {
+		log?.("Reloading IP location API");
+		updateDb({ fields, dataDir, tmpDataDir }).then(async () => {
+			await reload({ fields, dataDir, tmpDataDir });
+			log?.("IP location API reloaded");
+			initialized = true;
+			reloading = undefined;
+			resolve();
+		}).catch(reject);
+	});
+	return reloading;
+}

apps/api-master/src/functions/setSessionCounter.ts

@@ -0,0 +1,13 @@
+import { redis } from "../index.js";
+import { activeSessionsCounter } from "../tracing.js";
+
+let activeActivities = 0;
+activeSessionsCounter.add(0);
+export async function setSessionCounter() {
+	const length = await redis.hlen("pmd-api.sessions");
+	if (length === activeActivities)
+		return;
+	const diff = length - activeActivities;
+	activeActivities = length;
+	activeSessionsCounter.add(diff);
+}

apps/api-master/src/functions/updateActivePresenceGauge.ts

@@ -0,0 +1,64 @@
+import { redis } from "../index.js";
+import { activeIpsGauge, activePresenceGauge } from "../tracing.js";
+import { lookupIp } from "./lookupIp.js";
+
+//* Function to update the gauge with per-service counts
+export async function updateActivePresenceGauge() {
+	const pattern = "pmd-api.heartbeatUpdates.*";
+	let cursor: string = "0";
+	const serviceCounts = new Map<string, number>();
+	const ips = new Map<string, {
+		presences: string[];
+		sessions: number;
+	}>();
+
+	do {
+		const [newCursor, keys] = await redis.scan(cursor, "MATCH", pattern, "COUNT", 1000); //* Use SCAN with COUNT for memory efficiency
+		cursor = newCursor;
+		for (const key of keys) {
+			const hash = await redis.hgetall(key);
+			const service = hash.service;
+			const version = hash.version; //* Get version from hash
+			const ip = hash.ip_address;
+			if (service && version) {
+				serviceCounts.set(`${service}:${version}`, (serviceCounts.get(`${service}:${version}`) || 0) + 1);
+			}
+			else {
+				serviceCounts.set("none", (serviceCounts.get("none") || 0) + 1);
+			}
+			if (ip) {
+				const presenceName = service && version ? `${service}:${version}` : undefined;
+				const ipData = ips.get(ip) || { presences: [], sessions: 0 };
+				ipData.presences = [...new Set<string>([...ipData.presences, presenceName].filter(Boolean) as string[])];
+				ipData.sessions++;
+				ips.set(ip, ipData);
+			}
+		}
+	} while (cursor !== "0");
+
+	// Clear previous data
+	activePresenceGauge.clear();
+	activeIpsGauge.clear();
+
+	// Set new data
+	for (const [serviceVersion, count] of serviceCounts.entries()) {
+		const [presence_name, version] = serviceVersion.split(":");
+		activePresenceGauge.set(serviceVersion, count, {
+			presence_name,
+			version,
+		});
+	}
+
+	await Promise.all(Array.from(ips).map(async ([ip, { presences, sessions }]) => {
+		const parsed = await lookupIp(ip);
+		if (parsed) {
+			activeIpsGauge.set(ip, sessions, {
+				country: parsed.country,
+				ip,
+				latitude: parsed.latitude,
+				longitude: parsed.longitude,
+				presence_names: presences,
+			});
+		}
+	}));
+}

apps/api-master/src/index.ts

@@ -3,19 +3,55 @@ import { CronJob } from "cron";
 import debug from "debug";
 import { clearOldSessions } from "./functions/clearOldSessions.js";
 import createRedis from "./functions/createRedis.js";
+import { setSessionCounter } from "./functions/setSessionCounter.js";
+import "./tracing.js";
+import { updateActivePresenceGauge } from "./functions/updateActivePresenceGauge.js";
+import { reloadIpLocationApi } from "./functions/lookupIp.js";
 
 export const redis = createRedis();
 
 export const mainLog = debug("api-master");
 
-debug("Starting cron job to clear old sessions");
+reloadIpLocationApi();
+
+debug("Starting cron jobs");
 
 void new CronJob(
 	// Every 5 seconds
 	"*/5 * * * * *",
-	async () => {
+	() => {
 		clearOldSessions();
 	},
 	undefined,
 	true,
 );
+
+void new CronJob(
+	// Every second
+	"* * * * * *",
+	() => {
+		setSessionCounter();
+	},
+	undefined,
+	true,
+);
+
+void new CronJob(
+	// Every 5 seconds
+	"*/5 * * * * *",
+	() => {
+		updateActivePresenceGauge();
+	},
+	undefined,
+	true,
+);
+
+void new CronJob(
+	// Every day at 9am
+	"0 9 * * *",
+	() => {
+		reloadIpLocationApi();
+	},
+	undefined,
+	true,
+);

apps/api-master/src/tracing.ts

@@ -0,0 +1,31 @@
+import { ValueType } from "@opentelemetry/api";
+import { PrometheusExporter } from "@opentelemetry/exporter-prometheus";
+import { MeterProvider } from "@opentelemetry/sdk-metrics";
+import { ClearableGaugeMetric, updatePrometheusMetrics } from "./functions/clearableGaugeMetric.js";
+
+const prometheusExporter = new PrometheusExporter();
+
+const provider = new MeterProvider({
+	readers: [prometheusExporter],
+});
+
+const meter = provider.getMeter("nice");
+
+export const activeSessionsCounter = meter.createUpDownCounter("active_sessions", {
+	description: "Number of active sessions",
+	valueType: ValueType.INT,
+});
+
+export const activePresenceGauge = new ClearableGaugeMetric(
+	"active_presences",
+	"Per presence name+version, active number of users",
+);
+
+export const activeIpsGauge = new ClearableGaugeMetric(
+	"active_ips",
+	"Per ip, list of presences and the number of sessions",
+);
+
+updatePrometheusMetrics(prometheusExporter);
+
+prometheusExporter.startServer();

apps/api-master/tsconfig.app.json

@@ -3,6 +3,7 @@
 	"compilerOptions": {
 		"composite": true,
 		"rootDir": "src",
+		"types": ["./environment.d.ts"],
 		"outDir": "dist"
 	},
 	"include": ["src/**/*"]

apps/api-worker/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@premid/api-worker",
 	"type": "module",
-	"version": "0.0.6",
+	"version": "0.0.14",
 	"private": true,
 	"description": "PreMiD's api",
 	"license": "MPL-2.0",

apps/api-worker/src/classes/Socket.ts

@@ -54,7 +54,7 @@ export class Socket {
 					break;
 				}
 				case "session": {
-					await redis.del(`pmd:session:${out.token}`);
+					await redis.hdel("pmd-api.sessions", out.token);
 					this.currentSession = out;
 					break;
 				}
@@ -72,17 +72,15 @@ export class Socket {
 		if (!this.currentToken || !this.currentSession)
 			return;
 
-		const now = Math.floor(Date.now() / 1000);
-
-		await redis.hmset(
-			`pmd:session:${this.currentSession.token}`,
-			{
-				t: this.currentToken.token,
-				u: now,
-			},
+		await redis.hset(
+			"pmd-api.sessions",
+			this.currentSession.token,
+			JSON.stringify({
+				session: this.currentSession.token,
+				token: this.currentToken.token,
+				lastUpdated: Date.now(),
+			}),
 		);
-
-		await redis.expire(`pmd:session:${this.currentSession.token}`, 60); // Expire after 1 minute
 	}
 
 	async isTokenValid(token: typeof schema.token.infer) {

apps/api-worker/src/constants.ts

@@ -0,0 +1,10 @@
+import process from "node:process";
+import { defu } from "defu";
+
+const disabledFlags = process.env.DISABLED_FEATURE_FLAGS?.split(",") ?? [];
+const flags = Object.fromEntries(disabledFlags.map(flag => [flag, false]));
+
+export const featureFlags = defu(flags, {
+	WebSocketManager: true,
+	SessionKeepAlive: true,
+});

apps/api-worker/src/functions/createServer.ts

@@ -1,13 +1,10 @@
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import process from "node:process";
-import { useSentry } from "@envelop/sentry";
 import { maxAliasesPlugin } from "@escape.tech/graphql-armor-max-aliases";
 import { maxDepthPlugin } from "@escape.tech/graphql-armor-max-depth";
 import { maxDirectivesPlugin } from "@escape.tech/graphql-armor-max-directives";
 import { maxTokensPlugin } from "@escape.tech/graphql-armor-max-tokens";
 import fastifyWebsocket from "@fastify/websocket";
-import { defu } from "defu";
 import fastify from "fastify";
 
 import { createSchema, createYoga } from "graphql-yoga";
@@ -15,6 +12,7 @@ import type { FastifyReply, FastifyRequest } from "fastify";
 import { Socket } from "../classes/Socket.js";
 import { resolvers } from "../graphql/resolvers/v5/index.js";
 import { sessionKeepAlive } from "../routes/sessionKeepAlive.js";
+import { featureFlags } from "../constants.js";
 import createRedis from "./createRedis.js";
 
 export interface FastifyContext {
@@ -48,7 +46,7 @@ export default async function createServer() {
 			maxDepthPlugin(),
 			maxDirectivesPlugin(),
 			maxTokensPlugin(),
-			useSentry(),
+			/* useSentry(), */
 		],
 		schema: createSchema<FastifyContext>({
 			resolvers,
@@ -87,15 +85,7 @@ export default async function createServer() {
 	});
 
 	app.get("/v5/feature-flags", async (request, reply) => {
-		const disabledFlags = process.env.DISABLED_FEATURE_FLAGS?.split(",") ?? [];
-		const flags = Object.fromEntries(disabledFlags.map(flag => [flag, false]));
-
-		const test = defu(flags, {
-			WebSocketManager: true,
-			SessionKeepAlive: true,
-		});
-
-		void reply.send(test);
+		void reply.send(featureFlags);
 	});
 
 	app.post("/v5/session-keep-alive", sessionKeepAlive);

apps/api-worker/src/graphql/resolvers/v5/Mutation/addScience.ts

@@ -1,4 +1,5 @@
 import { type } from "arktype";
+import { GraphQLError } from "graphql";
 import { redis } from "../../../../functions/createServer.js";
 import type { MutationResolvers } from "../../../../generated/graphql-v5.js";
 
@@ -15,7 +16,7 @@ const mutation: MutationResolvers["addScience"] = async (_parent, input) => {
 	const out = addScienceSchema(input);
 
 	if (out instanceof type.errors)
-		throw new Error(out.summary);
+		throw new GraphQLError(out.summary);
 
 	await redis.hset(
 		"pmd-api.scienceUpdates",

apps/api-worker/src/graphql/resolvers/v5/Mutation/heartbeat.ts

@@ -1,15 +1,17 @@
 import { type } from "arktype";
+import { GraphQLError } from "graphql";
 import type { MutationResolvers } from "../../../../generated/graphql-v5.js";
+import { redis } from "../../../../functions/createServer.js";
 
 const heartbeatSchema = type({
-	identifier: "string.uuid & string.lower",
-	presences: {
+	"identifier": "string.uuid & string.lower",
+	"presence?": {
 		service: "string.trim",
 		version: "string.semver",
 		language: "string.trim",
 		since: "number.epoch",
 	},
-	extension: {
+	"extension": {
 		"version": "string.semver",
 		"language": "string.trim",
 		"connected?": {
@@ -19,19 +21,29 @@ const heartbeatSchema = type({
 	},
 });
 
-const mutation: MutationResolvers["heartbeat"] = async (_parent, input) => {
+const mutation: MutationResolvers["heartbeat"] = async (_parent, input, context) => {
 	const out = heartbeatSchema(input);
 
 	if (out instanceof type.errors)
-		throw new Error(out.summary);
+		throw new GraphQLError(out.summary);
 
-	// ! Disabled for now
-	/* await redis.setex(
-		`pmd-api.heartbeatUpdates.${data.identifier}`,
-		// 5 minutes
-		300,
-		JSON.stringify(data)
-	); */
+	//* Get the user's IP address from Cloudflare headers or fallback to the request IP
+	const userIp = context.request.headers.get("cf-connecting-ip") || context.request.ip;
+
+	// * Use Redis Hash with 'service' in the key to store heartbeat data
+	const redisKey = `pmd-api.heartbeatUpdates.${out.identifier}`;
+	await redis.hset(redisKey, {
+		service: out.presence?.service,
+		version: out.presence?.version,
+		language: out.presence?.language,
+		since: out.presence?.since.toString(),
+		extension_version: out.extension.version,
+		extension_language: out.extension.language,
+		extension_connected_app: out.extension.connected?.app?.toString(),
+		extension_connected_discord: out.extension.connected?.discord?.toString(),
+		ip_address: userIp,
+	});
+	await redis.expire(redisKey, 300);
 
 	return {
 		__typename: "HeartbeatResult",

apps/api-worker/src/graphql/resolvers/v5/Mutation/index.ts

@@ -1,6 +1,6 @@
+import type { MutationResolvers } from "../../../../generated/graphql-v5.js";
 import addScience from "./addScience.js";
 import heartbeat from "./heartbeat.js";
-import type { MutationResolvers } from "../../../../generated/graphql-v5.js";
 
 export const Mutation: MutationResolvers = {
 	addScience,

apps/api-worker/src/graphql/resolvers/v5/Query/index.ts

@@ -1,5 +1,5 @@
-import presences from "./presences.js";
 import type { QueryResolvers } from "../../../../generated/graphql-v5.js";
+import presences from "./presences.js";
 
 export const Query: QueryResolvers = {
 	presences,

apps/api-worker/src/graphql/resolvers/v5/index.ts

@@ -1,6 +1,6 @@
+import type { Resolvers } from "../../../generated/graphql-v5.js";
 import { Mutation } from "./Mutation/index.js";
 import { Query } from "./Query/index.js";
-import type { Resolvers } from "../../../generated/graphql-v5.js";
 
 export const resolvers: Resolvers = {
 	Query,

apps/api-worker/src/index.ts

@@ -3,8 +3,6 @@ import process from "node:process";
 import * as Sentry from "@sentry/node";
 import { connect } from "mongoose";
 import "./tracing.js";
-
-// eslint-disable-next-line perfectionist/sort-imports
 import createServer from "./functions/createServer.js";
 
 // TODO SETUP SENTRY

apps/api-worker/src/routes/sessionKeepAlive.ts

@@ -4,17 +4,25 @@ import { type } from "arktype";
 import { Routes } from "discord-api-types/v10";
 import type { FastifyReply, FastifyRequest } from "fastify";
 import { redis } from "../functions/createServer.js";
+import { featureFlags } from "../constants.js";
 
 const schema = type({
 	token: "string.trim",
 	session: "string.trim",
+	version: "string.semver & string.trim",
+	scienceId: "string.trim",
 });
 
 export async function sessionKeepAlive(request: FastifyRequest, reply: FastifyReply) {
-	//* Get the 2 headers
+	if (!featureFlags.SessionKeepAlive)
+		return reply.status(202).send();
+
+	//* Get the headers
 	const out = schema({
 		token: request.headers["x-token"],
 		session: request.headers["x-session"],
+		version: request.headers["x-version"] ?? "2.6.8",
+		scienceId: request.headers["x-science-id"] ?? request.headers["x-token"],
 	});
 
 	if (out instanceof type.errors)
@@ -23,20 +31,15 @@ export async function sessionKeepAlive(request: FastifyRequest, reply: FastifyRe
 	if (!await isTokenValid(out.token))
 		return reply.status(400).send({ code: "INVALID_TOKEN", message: "The token is invalid" });
 
-	const now = Math.floor(Date.now() / 1000); // Unix timestamp in seconds
+	const redisKey = `pmd-api.sessions.${out.scienceId}`;
+	await redis.hset(redisKey, {
+		session: out.session,
+		token: out.token,
+		lastUpdated: Date.now(),
+	});
+	await redis.expire(redisKey, 300); // 5 minutes
 
-	await redis.hmset(
-		`pmd:session:${out.session}`,
-		{
-			t: out.token,
-			u: now,
-		},
-	);
-
-	// Set expiration for the hash
-	await redis.expire(`pmd:session:${out.session}`, 60); // Expire after 1 minute
-
-	const interval = Number.parseInt(process.env.SESSION_KEEP_ALIVE_INTERVAL ?? "5000");
+	const interval = Number.parseInt(process.env.SESSION_KEEP_ALIVE_INTERVAL ?? "5000"); // 5 seconds
 
 	return reply.status(200).send({
 		code: "OK",

apps/pd/src/functions/createKeyv.ts

@@ -1,12 +1,11 @@
 import process from "node:process";
 import KeyvRedis from "@keyv/redis";
 import Keyv from "keyv";
-import type { KeyvOptions } from "keyv";
 
 import redis from "../redis.js";
 
 export default function createKeyv() {
-	let options: KeyvOptions | undefined;
+	let options: Keyv.Options<string> | undefined;
 
 	/* c8 ignore next 8 */
 	if (process.env.REDIS_SENTINELS) {
@@ -16,7 +15,7 @@ export default function createKeyv() {
 		};
 	}
 
-	const keyv = new Keyv(
+	const keyv = new Keyv<string>(
 		options,
 	);
 

apps/pd/src/routes/createFromImage.test.ts

@@ -1,9 +1,9 @@
 import { Buffer } from "node:buffer";
 import { readFile } from "node:fs/promises";
-import { afterAll, beforeAll, describe, it } from "vitest";
 
 import type { RequestOptions } from "node:http";
 import type { AddressInfo } from "node:net";
+import { afterAll, beforeAll, describe, it } from "vitest";
 
 import { createServer } from "../functions/createServer.js";
 

apps/pd/src/routes/createShortenedLink.ts

@@ -20,7 +20,7 @@ const handler: RouteHandlerMethod = async (request, reply) => {
 		return reply.status(400).send("Invalid URL");
 
 	const hash = crypto.createHash("sha256").update(url).digest("hex");
-	const existingShortenedUrl = await keyv.get<string>(hash);
+	const existingShortenedUrl = await keyv.get(hash);
 
 	void reply.header("Cache-control", "public, max-age=1800");
 

apps/pd/src/routes/getFullLink.ts

@@ -25,7 +25,7 @@ const handler: RouteHandlerMethod = async (request, reply) => {
 	if (id.split(".")[0]?.length !== 10)
 		return reply.code(404).send("Invalid ID");
 
-	const url = await keyv.get<string>(id);
+	const url = await keyv.get(id);
 	if (!url)
 		return reply.code(404).send("Unknown ID");
 

apps/website/server/api/getStaffData.ts

@@ -1,4 +1,4 @@
-import { ActivityType, flagsToBadges, PresenceUpdateStatus } from "@discord-user-card/vue";
+import { ActivityType, PresenceUpdateStatus, flagsToBadges } from "@discord-user-card/vue";
 import { REST } from "@discordjs/rest";
 import { Routes } from "discord-api-types/v10";
 import type { DiscordUserCardActivity, DiscordUserCardUser } from "@discord-user-card/vue";

package.json

@@ -38,5 +38,10 @@
 		"prettier": "^3.2.5",
 		"typescript": "^5.5.4",
 		"vitest": "^2.0.2"
+	},
+	"pnpm": {
+		"patchedDependencies": {
+			"ip-location-api@1.0.0": "patches/ip-location-api@1.0.0.patch"
+		}
 	}
 }

patches/ip-location-api@1.0.0.patch

@@ -0,0 +1,62 @@
+diff --git a/browser/country/README.md b/browser/country/README.md
+deleted file mode 100644
+index ac8fc934b4998f2a2cb7a92bf68bbdadd9e3d36d..0000000000000000000000000000000000000000
+diff --git a/browser/country-extra/README.md b/browser/country-extra/README.md
+deleted file mode 100644
+index 71e7237722915b2697b56ccb14171524eb4b40fb..0000000000000000000000000000000000000000
+diff --git a/browser/geocode/README.md b/browser/geocode/README.md
+deleted file mode 100644
+index 9d9a2205061f332b363b82d7561a0e3829d5bf2c..0000000000000000000000000000000000000000
+diff --git a/browser/geocode-extra/README.md b/browser/geocode-extra/README.md
+deleted file mode 100644
+index 38e17eebdd8532d07b460fbe7f385f36625ece9d..0000000000000000000000000000000000000000
+diff --git a/src/db.mjs b/src/db.mjs
+index 378b8a22084f860cc89720d1783a235c034717b2..cbffe1eaa84a94df536059d4b4af3f8f5ceb0ca7 100644
+--- a/src/db.mjs
++++ b/src/db.mjs
+@@ -33,7 +33,12 @@ export const update = async () => {
+ 	if(refreshTmpDir || !fsSync.existsSync(setting.tmpDataDir)){
+ 		// refresh tmp folder
+ 		await rimraf(setting.tmpDataDir)
+-		await fs.mkdir(setting.tmpDataDir)
++		await fs.mkdir(setting.tmpDataDir, {recursive: true})
++	}
++
++	// When specifying a custom dataDir, it doesn't always exists
++	if (!fsSync.existsSync(setting.dataDir)){
++		await fs.mkdir(setting.dataDir, {recursive: true})
+ 	}
+ 
+ 	console.log('Downloading database')
+diff --git a/src/main.mjs b/src/main.mjs
+index d001aca60902bc7fe41271c6fa7a0b6648607b15..5b2c125d8e7590afee82c794bf771accd656b2b7 100644
+--- a/src/main.mjs
++++ b/src/main.mjs
+@@ -3,7 +3,7 @@ import fs from 'fs/promises'
+ import fsSync from 'fs'
+ import path from 'path'
+ import { exec } from 'child_process'
+-
++import { fileURLToPath } from "url"
+ import { countries, continents } from 'countries-list'
+ 
+ import { setting, setSetting, getSettingCmd } from './setting.mjs'
+@@ -14,6 +14,9 @@ const v6db = setting.v6
+ const locFieldHash = setting.locFieldHash
+ const mainFieldHash = setting.mainFieldHash
+ 
++const __filename = fileURLToPath(import.meta.url)
++const __dirname = path.dirname(__filename)
++
+ //---------------------------------------
+ // Database lookup
+ //---------------------------------------
+@@ -235,7 +238,7 @@ export const updateDb = (_setting) => {
+ 	// However, db.js import many external modules, it makes slow down the startup time and uses more memory.
+ 	// Therefore, we use exec() to run the script in the other process.
+ 	return new Promise((resolve, reject) => {
+-		var cmd = 'node ' + path.resolve(__dirname, '..', 'script', 'updatedb.js')
++		var cmd = 'node ' + path.resolve(__dirname, '..', 'script', 'updatedb.mjs')
+ 		var arg
+ 		if(_setting){
+ 			var oldSetting = Object.assign({}, setting)