Merge pull request #39 from sebastiankrll/infra/cdn

Infra/cdn

Author: sebastiankrll

apps/updater/package.json

@@ -16,6 +16,7 @@
 		"typescript": "^5.9.3"
 	},
 	"dependencies": {
+		"@aws-sdk/client-s3": "^3.948.0",
 		"@sr24/db": "*",
 		"@sr24/types": "*",
 		"axios": "^1.13.2",

apps/updater/src/index.ts

@@ -5,6 +5,7 @@ import { updateAirlines } from "./airlines.js";
 import { updateAirports } from "./airports.js";
 import { updateFirs } from "./fir.js";
 import { updateFleets } from "./fleet.js";
+import { updateR2Storage } from "./s3.js";
 import { updateTracons } from "./tracon.js";
 
 let dbsInitialized = false;
@@ -23,6 +24,8 @@ CronJob.from({
 		await updateTracons();
 		await updateFleets();
 
+		await updateR2Storage();
+
 		console.log("✅ Static data update completed!");
 	},
 	start: true,

apps/updater/src/s3.ts

@@ -0,0 +1,53 @@
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { rdsGetMultiple } from "@sr24/db/redis";
+
+const accountId = process.env.CF_ACCOUNT_ID || "";
+const accessKeyId = process.env.R2_ACCESS_KEY_ID || "";
+const secret = process.env.R2_SECRET_ACCESS_KEY || "";
+const bucket = process.env.R2_BUCKET_NAME || "";
+
+const r2 = new S3Client({
+	region: "auto",
+	endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+	credentials: { accessKeyId, secretAccessKey: secret },
+});
+
+export async function updateR2Storage(): Promise<void> {
+	const versions: string[] = await rdsGetMultiple("", [
+		"static_airports:version",
+		"static_firs:version",
+		"static_tracons:version",
+		"static_airlines:version",
+	]);
+	const manifest = {
+		airportsVersion: versions[0],
+		firsVersion: versions[1],
+		traconsVersion: versions[2],
+		airlinesVersion: versions[3],
+	};
+
+	await uploadManifestToR2(manifest);
+
+	const datas = await rdsGetMultiple("", ["static_airports:all", "static_firs:all", "static_tracons:all", "static_airlines:all"]);
+	await uploadDataToR2(`airports_${manifest.airportsVersion}.json`, JSON.stringify(datas[0]));
+	await uploadDataToR2(`firs_${manifest.firsVersion}.json`, JSON.stringify(datas[1]));
+	await uploadDataToR2(`tracons_${manifest.traconsVersion}.json`, JSON.stringify(datas[2]));
+	await uploadDataToR2(`airlines_${manifest.airlinesVersion}.json`, JSON.stringify(datas[3]));
+
+	console.log("✅ R2 storage update completed!");
+}
+
+async function uploadDataToR2(key: string, body: Buffer | Uint8Array | Blob | string) {
+	return await r2.send(
+		new PutObjectCommand({
+			Bucket: bucket,
+			Key: key,
+			Body: body,
+		}),
+	);
+}
+
+async function uploadManifestToR2(manifest: object) {
+	const manifestJson = JSON.stringify(manifest);
+	return await uploadDataToR2("manifest.json", manifestJson);
+}

apps/web/storage/dexie.ts

@@ -8,37 +8,47 @@ interface StaticVersions {
 	firsVersion: string;
 	airlinesVersion: string;
 }
-
 interface DexieFeature {
 	id: string;
 	feature: FIRFeature | SimAwareTraconFeature;
 }
+type Manifest = { key: string; versions: StaticVersions };
+
+const R2_BUCKET_URL = process.env.NODE_ENV === "development" ? process.env.NEXT_PUBLIC_R2_BUCKET_URL_DEV : process.env.NEXT_PUBLIC_R2_BUCKET_URL;
 
 const db = new Dexie("StaticDatabase") as Dexie & {
 	airports: EntityTable<StaticAirport, "id">;
 	firs: EntityTable<DexieFeature, "id">;
 	tracons: EntityTable<DexieFeature, "id">;
 	airlines: EntityTable<StaticAirline, "id">;
+	manifest: EntityTable<Manifest, "key">;
 };
 
 db.version(1).stores({
 	airports: "id",
 	firs: "id",
 	tracons: "id",
 	airlines: "id",
+	manifest: "key",
 });
 
 export async function dxInitDatabases(): Promise<void> {
-	const serverVersions = await fetchApi<StaticVersions>("/static/versions");
-	const localVersions: StaticVersions = JSON.parse(localStorage.getItem("databaseVersions") || "{}");
-
-	if (serverVersions.airportsVersion !== localVersions.airportsVersion) {
-		const entries = (await fetchStaticData("airports")) as StaticAirport[];
+	const latestManifest = await fetchApi<StaticVersions>(`${R2_BUCKET_URL}/manifest.json`, {
+		cache: "no-store",
+	});
+	const storedManifest = (await db.manifest.get("databaseVersions")) as Manifest | undefined;
+
+	if (latestManifest.airportsVersion !== storedManifest?.versions.airportsVersion) {
+		const entries = (await fetchApi<StaticAirport[]>(`${R2_BUCKET_URL}/airports_${latestManifest.airportsVersion}.json`, {
+			cache: "no-store",
+		})) as StaticAirport[];
 		storeData(entries, db.airports as EntityTable<any, "id">);
 	}
 
-	if (serverVersions.firsVersion !== localVersions.firsVersion) {
-		const features = (await fetchStaticData("firs")) as FIRFeature[];
+	if (latestManifest.firsVersion !== storedManifest?.versions.firsVersion) {
+		const features = (await fetchApi<FIRFeature[]>(`${R2_BUCKET_URL}/firs_${latestManifest.firsVersion}.json`, {
+			cache: "no-store",
+		})) as FIRFeature[];
 		const entries: DexieFeature[] = features.map((f) => ({
 			id: f.properties.id,
 			feature: f,
@@ -47,8 +57,10 @@ export async function dxInitDatabases(): Promise<void> {
 		storeData(entries, db.firs as EntityTable<any, "id">);
 	}
 
-	if (serverVersions.traconsVersion !== localVersions.traconsVersion) {
-		const features = (await fetchStaticData("tracons")) as SimAwareTraconFeature[];
+	if (latestManifest.traconsVersion !== storedManifest?.versions.traconsVersion) {
+		const features = (await fetchApi<SimAwareTraconFeature[]>(`${R2_BUCKET_URL}/tracons_${latestManifest.traconsVersion}.json`, {
+			cache: "no-store",
+		})) as SimAwareTraconFeature[];
 		const entries: DexieFeature[] = features.map((f) => ({
 			id: f.properties.id,
 			feature: f,
@@ -57,16 +69,14 @@ export async function dxInitDatabases(): Promise<void> {
 		storeData(entries, db.tracons as EntityTable<any, "id">);
 	}
 
-	if (serverVersions.airlinesVersion !== localVersions.airlinesVersion) {
-		const entries = (await fetchStaticData("airlines")) as StaticAirline[];
+	if (latestManifest.airlinesVersion !== storedManifest?.versions.airlinesVersion) {
+		const entries = (await fetchApi<StaticAirline[]>(`${R2_BUCKET_URL}/airlines_${latestManifest.airlinesVersion}.json`, {
+			cache: "no-store",
+		})) as StaticAirline[];
 		storeData(entries, db.airlines as EntityTable<any, "id">);
 	}
 
-	localStorage.setItem("databaseVersions", JSON.stringify(serverVersions));
-}
-
-async function fetchStaticData(type: string): Promise<any> {
-	return await fetchApi<any>(`/static/${type}`);
+	await db.manifest.put({ key: "databaseVersions", versions: latestManifest });
 }
 
 async function storeData(data: any[], db: EntityTable<any, "id">): Promise<void> {

docker/docker-compose.prod.yml

@@ -60,6 +60,7 @@ services:
       args:
         NEXT_PUBLIC_API_URL: "https://${DOMAIN}/api"
         NEXT_PUBLIC_WEBSOCKET_URL: "wss://${DOMAIN}/ws"
+        NEXT_PUBLIC_R2_BUCKET_URL: ${NEXT_PUBLIC_R2_BUCKET_URL}
     container_name: sr24_web
     restart: always
     environment:
@@ -194,6 +195,10 @@ services:
       REDIS_PORT: ${REDIS_PORT}
       REDIS_PASSWORD: ${REDIS_PASSWORD}
       REDIS_DB: ${REDIS_DB}
+      CF_ACCOUNT_ID: ${CF_ACCOUNT_ID}
+      R2_ACCESS_KEY_ID: ${R2_ACCESS_KEY_ID}
+      R2_SECRET_ACCESS_KEY: ${R2_SECRET_ACCESS_KEY}
+      R2_BUCKET_NAME: ${R2_BUCKET_NAME}
     depends_on:
       postgres:
         condition: service_healthy