refactor!: serve the static frontend trough the backend (#520)

Co-authored-by: Alessandro (Ale) Segala <43508+ItalyPaleAle@users.noreply.github.com>

frontend/src/lib/services/api-service.ts

@@ -1,19 +1,13 @@
-import { browser } from '$app/environment';
 import axios from 'axios';
 
 abstract class APIService {
 	api = axios.create({
-		withCredentials: true
+		baseURL: '/api'
 	});
 
-	constructor(accessToken?: string) {
-		if (accessToken) {
-			this.api.defaults.headers.common['Authorization'] = `Bearer ${accessToken}`;
-		}
-		if (browser) {
-			this.api.defaults.baseURL = '/api';
-		} else {
-			this.api.defaults.baseURL = process!.env!.INTERNAL_BACKEND_URL + '/api';
+	constructor() {
+		if (typeof process !== 'undefined' && process?.env?.DEVELOPMENT_BACKEND_URL) {
+			this.api.defaults.baseURL = process.env.DEVELOPMENT_BACKEND_URL;
 		}
 	}
 }

frontend/src/lib/services/app-config-service.ts

@@ -1,6 +1,4 @@
-import { version as currentVersion } from '$app/environment';
 import type { AllAppConfig, AppConfigRawResponse } from '$lib/types/application-configuration';
-import axios from 'axios';
 import APIService from './api-service';
 
 export default class AppConfigService extends APIService {
@@ -55,28 +53,6 @@ export default class AppConfigService extends APIService {
 		await this.api.post('/application-configuration/sync-ldap');
 	}
 
-	async getVersionInformation() {
-		const response = await axios
-			.get('https://api.github.com/repos/pocket-id/pocket-id/releases/latest', {
-				timeout: 2000
-			})
-			.then((res) => res.data)
-			.catch(() => null);
-
-		let newestVersion: string | undefined;
-		let isUpToDate: boolean | undefined;
-		if (response) {
-			newestVersion = response.tag_name.replace('v', '');
-			isUpToDate = newestVersion === currentVersion;
-		}
-
-		return {
-			isUpToDate,
-			newestVersion,
-			currentVersion
-		};
-	}
-
 	private parseConfigList(data: AppConfigRawResponse) {
 		const appConfig: Partial<AllAppConfig> = {};
 		data.forEach(({ key, value }) => {

frontend/src/lib/services/version-service.ts

@@ -0,0 +1,109 @@
+import { version as currentVersion } from '$app/environment';
+import axios from 'axios';
+
+const VERSION_CACHE_KEY = 'version_cache';
+const CACHE_DURATION = 2 * 60 * 60 * 1000; // 2 hours
+
+async function getNewestVersion() {
+	const cachedData = await getVersionFromCache();
+
+	// If we have valid cached data, return it
+	if (cachedData) {
+		return cachedData;
+	}
+
+	// Otherwise fetch from API
+	try {
+		const response = await axios
+			.get('https://api.github.com/repos/pocket-id/pocket-id/releases/latest', {
+				timeout: 2000
+			})
+			.then((res) => res.data);
+		console.log('Fetched newest version:', response);
+		const newestVersion = response.tag_name.replace('v', '');
+
+		// Cache the result
+		cacheVersion(newestVersion);
+
+		return newestVersion;
+	} catch (error) {
+		console.error('Failed to fetch newest version:', error);
+		// If fetch fails but we have an expired cache, return that as fallback
+		const cache = getCacheObject();
+		return cache?.newestVersion || currentVersion;
+	}
+}
+
+function getCurrentVersion() {
+	return currentVersion;
+}
+
+async function isUpToDate() {
+	const newestVersion = await getNewestVersion();
+	const currentVersion = getCurrentVersion();
+
+	// If the current version changed, invalidate the cache
+	const cache = getCacheObject();
+	if (cache?.lastCurrentVersion && currentVersion !== cache.lastCurrentVersion) {
+		invalidateCache();
+	}
+
+	return newestVersion === currentVersion;
+}
+
+// Helper methods for caching
+function getCacheObject() {
+	const cacheJson = localStorage.getItem(VERSION_CACHE_KEY);
+	if (!cacheJson) return null;
+
+	try {
+		return JSON.parse(cacheJson);
+	} catch (e) {
+		console.error('Failed to parse cache:', e);
+		return null;
+	}
+}
+
+async function getVersionFromCache() {
+	const cache = getCacheObject();
+
+	if (!cache || !cache.newestVersion || !cache.timestamp) {
+		return null;
+	}
+
+	const now = Date.now();
+
+	// Check if cache is still valid
+	if (now - cache.timestamp > CACHE_DURATION) {
+		invalidateCache();
+		return null;
+	}
+
+	// Check if current version matches what it was when we cached
+	if (cache.lastCurrentVersion && cache.lastCurrentVersion !== currentVersion) {
+		invalidateCache();
+		return null;
+	}
+
+	return cache.newestVersion;
+}
+
+async function cacheVersion(version :string) {
+	const cacheObject = {
+		newestVersion: version,
+		timestamp: Date.now(),
+		lastCurrentVersion: currentVersion
+	};
+
+	localStorage.setItem(VERSION_CACHE_KEY, JSON.stringify(cacheObject));
+}
+
+async function invalidateCache() {
+	localStorage.removeItem(VERSION_CACHE_KEY);
+}
+
+export default {
+	getNewestVersion,
+	getCurrentVersion,
+	isUpToDate
+};