fix: analytics event endpoint (#6938)

* fix: analytics event endpoint

* split admin-only routes into internal

* fix pr comment

apps/frontend/src/pages/admin/analytics/events.vue

@@ -485,9 +485,9 @@ async function saveEvent() {
 		const payload = buildEventPayload()
 
 		if (modalMode.value === 'edit' && editingEventId.value !== null) {
-			await client.labrinth.analytics_v3.editEvent(editingEventId.value, payload)
+			await client.labrinth.analytics_internal.editEvent(editingEventId.value, payload)
 		} else {
-			await client.labrinth.analytics_v3.createEvent(payload)
+			await client.labrinth.analytics_internal.createEvent(payload)
 		}
 
 		await queryClient.invalidateQueries({ queryKey: analyticsEventsQueryKey })
@@ -528,7 +528,7 @@ async function deleteEvent(eventId: Labrinth.Analytics.v3.AnalyticsEventId) {
 	setDeletingEvent(eventId, true)
 
 	try {
-		await client.labrinth.analytics_v3.deleteEvent(eventId)
+		await client.labrinth.analytics_internal.deleteEvent(eventId)
 		await queryClient.invalidateQueries({ queryKey: analyticsEventsQueryKey })
 		addNotification({
 			title: 'Analytics event deleted',
@@ -581,7 +581,7 @@ function commitAnnouncementUrl() {
 	committedAnnouncementUrl.value = form.value.announcementUrl
 }
 
-function buildEventPayload(): Labrinth.Analytics.v3.AnalyticsEventUpsert {
+function buildEventPayload(): Labrinth.Analytics.Internal.AnalyticsEventUpsert {
 	const selectedRange = getEventFormDateRange()
 	if (!selectedRange) {
 		throw new Error('Select a valid start and end date')

apps/labrinth/src/routes/internal/analytics_event.rs

@@ -0,0 +1,192 @@
+use actix_web::{HttpRequest, delete, patch, post, web};
+use chrono::{DateTime, Utc};
+use eyre::eyre;
+use serde::{Deserialize, Serialize};
+use xredis::RedisPool;
+
+use crate::{
+    auth::get_user_from_headers,
+    database::{
+        PgPool,
+        models::{
+            DBAnalyticsEvent, DBAnalyticsEventId, generate_analytics_event_id,
+        },
+    },
+    models::{
+        ids::AnalyticsEventId,
+        pats::Scopes,
+        v3::analytics_event::{AnalyticsEvent, AnalyticsEventMeta},
+    },
+    queue::session::AuthQueue,
+    routes::ApiError,
+    util::error::Context,
+};
+
+pub fn config(cfg: &mut actix_web::web::ServiceConfig) {
+    cfg.service(analytics_event_create)
+        .service(analytics_event_edit)
+        .service(analytics_event_delete);
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
+pub struct AnalyticsEventUpsert {
+    #[serde(flatten)]
+    pub meta: AnalyticsEventMeta,
+    pub starts: DateTime<Utc>,
+    pub ends: DateTime<Utc>,
+}
+
+/// Create an analytics event.  
+#[utoipa::path(
+	context_path = "/analytics-event",
+	tag = "analytics events", responses((status = OK, body = AnalyticsEvent))
+)]
+#[post("")]
+pub async fn analytics_event_create(
+    req: HttpRequest,
+    event: web::Json<AnalyticsEventUpsert>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<web::Json<AnalyticsEvent>, ApiError> {
+    let user = get_user_from_headers(
+        &req,
+        &**pool,
+        &redis,
+        &session_queue,
+        Scopes::empty(),
+    )
+    .await?
+    .1;
+
+    if !user.role.is_admin() {
+        return Err(ApiError::Auth(eyre!(
+            "you do not have permission to manage analytics events"
+        )));
+    }
+
+    let mut transaction = pool
+        .begin()
+        .await
+        .wrap_internal_err("failed to begin transaction")?;
+    let id = generate_analytics_event_id(&mut transaction)
+        .await
+        .wrap_internal_err("failed to generate analytics event ID")?;
+
+    let event = DBAnalyticsEvent {
+        id,
+        meta: event.meta.clone(),
+        starts: event.starts,
+        ends: event.ends,
+    };
+    event
+        .insert(&mut transaction)
+        .await
+        .wrap_internal_err("failed to insert analytics event")?;
+
+    transaction
+        .commit()
+        .await
+        .wrap_internal_err("failed to commit transaction")?;
+    DBAnalyticsEvent::clear_cache(&redis)
+        .await
+        .wrap_internal_err("failed to clear analytics event cache")?;
+
+    Ok(web::Json(event.into()))
+}
+
+/// Update an analytics event.  
+#[utoipa::path(
+	context_path = "/analytics-event",
+	tag = "analytics events", responses((status = OK, body = AnalyticsEvent))
+)]
+#[patch("/{id}")]
+pub async fn analytics_event_edit(
+    req: HttpRequest,
+    id: web::Path<(AnalyticsEventId,)>,
+    event: web::Json<AnalyticsEventUpsert>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<web::Json<AnalyticsEvent>, ApiError> {
+    let user = get_user_from_headers(
+        &req,
+        &**pool,
+        &redis,
+        &session_queue,
+        Scopes::empty(),
+    )
+    .await?
+    .1;
+
+    if !user.role.is_admin() {
+        return Err(ApiError::Auth(eyre!(
+            "you do not have permission to manage analytics events"
+        )));
+    }
+
+    let event = DBAnalyticsEvent {
+        id: DBAnalyticsEventId::from(id.into_inner().0),
+        meta: event.meta.clone(),
+        starts: event.starts,
+        ends: event.ends,
+    };
+
+    let updated = event
+        .update(&**pool)
+        .await
+        .wrap_internal_err("failed to update analytics event")?;
+    if !updated {
+        return Err(ApiError::NotFound);
+    }
+    DBAnalyticsEvent::clear_cache(&redis)
+        .await
+        .wrap_internal_err("failed to clear analytics event cache")?;
+
+    Ok(web::Json(event.into()))
+}
+
+/// Delete an analytics event.  
+#[utoipa::path(
+	context_path = "/analytics-event",
+	tag = "analytics events", responses((status = NO_CONTENT))
+)]
+#[delete("/{id}")]
+pub async fn analytics_event_delete(
+    req: HttpRequest,
+    id: web::Path<(AnalyticsEventId,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<(), ApiError> {
+    let user = get_user_from_headers(
+        &req,
+        &**pool,
+        &redis,
+        &session_queue,
+        Scopes::empty(),
+    )
+    .await?
+    .1;
+
+    if !user.role.is_admin() {
+        return Err(ApiError::Auth(eyre!(
+            "you do not have permission to manage analytics events"
+        )));
+    }
+
+    let deleted = DBAnalyticsEvent::remove(
+        DBAnalyticsEventId::from(id.into_inner().0),
+        &**pool,
+    )
+    .await
+    .wrap_internal_err("failed to delete analytics event")?;
+    if !deleted {
+        return Err(ApiError::NotFound);
+    }
+    DBAnalyticsEvent::clear_cache(&redis)
+        .await
+        .wrap_internal_err("failed to clear analytics event cache")?;
+
+    Ok(())
+}

apps/labrinth/src/routes/internal/mod.rs

@@ -1,5 +1,6 @@
 pub mod admin;
 pub mod affiliate;
+pub mod analytics_event;
 pub mod attribution;
 pub mod billing;
 pub mod blocked_users;
@@ -35,6 +36,10 @@ pub fn config(cfg: &mut web::ServiceConfig) {
             .configure(flows::config)
             .configure(pats::config)
             .configure(oauth_clients::config)
+            .service(
+                web::scope("/analytics-event")
+                    .configure(analytics_event::config),
+            )
             .service(web::scope("/moderation").configure(moderation::config))
             .service(web::scope("/affiliate").configure(affiliate::config))
             .service(web::scope("/campaign").configure(campaign::config))
@@ -50,11 +55,6 @@ pub fn config(cfg: &mut web::ServiceConfig) {
             .configure(medal::config)
             .configure(mural::config)
             .configure(statuses::config),
-    )
-    .service(
-        web::scope("/v3/analytics-event")
-            .wrap(default_cors())
-            .configure(super::v3::analytics_event::config),
     );
 }
 
@@ -180,10 +180,9 @@ pub fn config(cfg: &mut web::ServiceConfig) {
 		medal::redeem,
 		mural::get_bank_details,
 		statuses::ws_init,
-		super::v3::analytics_event::analytics_events_get,
-		super::v3::analytics_event::analytics_event_create,
-		super::v3::analytics_event::analytics_event_edit,
-		super::v3::analytics_event::analytics_event_delete,
+		analytics_event::analytics_event_create,
+		analytics_event::analytics_event_edit,
+		analytics_event::analytics_event_delete,
 	),
 	modifiers(&InternalPathModifier, &SecurityAddon)
 )]

apps/labrinth/src/routes/v3/analytics_event.rs

@@ -1,48 +1,22 @@
-use actix_web::{HttpRequest, delete, get, patch, post, web};
-use chrono::{DateTime, Utc};
-use eyre::eyre;
-use serde::{Deserialize, Serialize};
+use actix_web::{get, web};
 use xredis::RedisPool;
 
 use crate::{
-    auth::get_user_from_headers,
-    database::{
-        PgPool,
-        models::{
-            DBAnalyticsEvent, DBAnalyticsEventId, generate_analytics_event_id,
-        },
-    },
-    models::{
-        ids::AnalyticsEventId,
-        pats::Scopes,
-        v3::analytics_event::{AnalyticsEvent, AnalyticsEventMeta},
-    },
-    queue::session::AuthQueue,
+    database::{PgPool, models::DBAnalyticsEvent},
+    models::v3::analytics_event::AnalyticsEvent,
     routes::ApiError,
     util::error::Context,
 };
 
 pub fn config(cfg: &mut actix_web::web::ServiceConfig) {
-    cfg.service(analytics_events_get)
-        .service(analytics_event_create)
-        .service(analytics_event_edit)
-        .service(analytics_event_delete);
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
-pub struct AnalyticsEventUpsert {
-    #[serde(flatten)]
-    pub meta: AnalyticsEventMeta,
-    pub starts: DateTime<Utc>,
-    pub ends: DateTime<Utc>,
+    cfg.service(analytics_events_get);
 }
 
 /// List analytics events.
 #[utoipa::path(
-	context_path = "/v3/analytics-event",
 	tag = "v3 analytics", responses((status = OK, body = Vec<AnalyticsEvent>))
 )]
-#[get("")]
+#[get("/analytics-event")]
 pub async fn analytics_events_get(
     pool: web::Data<PgPool>,
     redis: web::Data<RedisPool>,
@@ -56,158 +30,3 @@ pub async fn analytics_events_get(
 
     Ok(web::Json(events))
 }
-
-/// Create an analytics event.  
-#[utoipa::path(
-	context_path = "/v3/analytics-event",
-	tag = "v3 analytics", responses((status = OK, body = AnalyticsEvent))
-)]
-#[post("")]
-pub async fn analytics_event_create(
-    req: HttpRequest,
-    event: web::Json<AnalyticsEventUpsert>,
-    pool: web::Data<PgPool>,
-    redis: web::Data<RedisPool>,
-    session_queue: web::Data<AuthQueue>,
-) -> Result<web::Json<AnalyticsEvent>, ApiError> {
-    let user = get_user_from_headers(
-        &req,
-        &**pool,
-        &redis,
-        &session_queue,
-        Scopes::empty(),
-    )
-    .await?
-    .1;
-
-    if !user.role.is_admin() {
-        return Err(ApiError::Auth(eyre!(
-            "you do not have permission to manage analytics events"
-        )));
-    }
-
-    let mut transaction = pool
-        .begin()
-        .await
-        .wrap_internal_err("failed to begin transaction")?;
-    let id = generate_analytics_event_id(&mut transaction)
-        .await
-        .wrap_internal_err("failed to generate analytics event ID")?;
-
-    let event = DBAnalyticsEvent {
-        id,
-        meta: event.meta.clone(),
-        starts: event.starts,
-        ends: event.ends,
-    };
-    event
-        .insert(&mut transaction)
-        .await
-        .wrap_internal_err("failed to insert analytics event")?;
-
-    transaction
-        .commit()
-        .await
-        .wrap_internal_err("failed to commit transaction")?;
-    DBAnalyticsEvent::clear_cache(&redis)
-        .await
-        .wrap_internal_err("failed to clear analytics event cache")?;
-
-    Ok(web::Json(event.into()))
-}
-
-/// Update an analytics event.  
-#[utoipa::path(
-	context_path = "/v3/analytics-event",
-	tag = "v3 analytics", responses((status = OK, body = AnalyticsEvent))
-)]
-#[patch("/{id}")]
-pub async fn analytics_event_edit(
-    req: HttpRequest,
-    id: web::Path<(AnalyticsEventId,)>,
-    event: web::Json<AnalyticsEventUpsert>,
-    pool: web::Data<PgPool>,
-    redis: web::Data<RedisPool>,
-    session_queue: web::Data<AuthQueue>,
-) -> Result<web::Json<AnalyticsEvent>, ApiError> {
-    let user = get_user_from_headers(
-        &req,
-        &**pool,
-        &redis,
-        &session_queue,
-        Scopes::empty(),
-    )
-    .await?
-    .1;
-
-    if !user.role.is_admin() {
-        return Err(ApiError::Auth(eyre!(
-            "you do not have permission to manage analytics events"
-        )));
-    }
-
-    let event = DBAnalyticsEvent {
-        id: DBAnalyticsEventId::from(id.into_inner().0),
-        meta: event.meta.clone(),
-        starts: event.starts,
-        ends: event.ends,
-    };
-
-    let updated = event
-        .update(&**pool)
-        .await
-        .wrap_internal_err("failed to update analytics event")?;
-    if !updated {
-        return Err(ApiError::NotFound);
-    }
-    DBAnalyticsEvent::clear_cache(&redis)
-        .await
-        .wrap_internal_err("failed to clear analytics event cache")?;
-
-    Ok(web::Json(event.into()))
-}
-
-/// Delete an analytics event.  
-#[utoipa::path(
-	context_path = "/v3/analytics-event",
-	tag = "v3 analytics", responses((status = NO_CONTENT))
-)]
-#[delete("/{id}")]
-pub async fn analytics_event_delete(
-    req: HttpRequest,
-    id: web::Path<(AnalyticsEventId,)>,
-    pool: web::Data<PgPool>,
-    redis: web::Data<RedisPool>,
-    session_queue: web::Data<AuthQueue>,
-) -> Result<(), ApiError> {
-    let user = get_user_from_headers(
-        &req,
-        &**pool,
-        &redis,
-        &session_queue,
-        Scopes::empty(),
-    )
-    .await?
-    .1;
-
-    if !user.role.is_admin() {
-        return Err(ApiError::Auth(eyre!(
-            "you do not have permission to manage analytics events"
-        )));
-    }
-
-    let deleted = DBAnalyticsEvent::remove(
-        DBAnalyticsEventId::from(id.into_inner().0),
-        &**pool,
-    )
-    .await
-    .wrap_internal_err("failed to delete analytics event")?;
-    if !deleted {
-        return Err(ApiError::NotFound);
-    }
-    DBAnalyticsEvent::clear_cache(&redis)
-        .await
-        .wrap_internal_err("failed to clear analytics event cache")?;
-
-    Ok(())
-}

apps/labrinth/src/routes/v3/mod.rs

@@ -49,6 +49,7 @@ pub fn config(cfg: &mut web::ServiceConfig) {
     cfg.service(
         web::scope("/v3")
             .wrap(default_cors())
+            .configure(analytics_event::config)
             .configure(limits::config)
             .configure(collections::config)
             .configure(images::config)
@@ -80,6 +81,7 @@ pub fn config(cfg: &mut web::ServiceConfig) {
 		description = include_str!("../../api_v3_description.md"),
 	),
 	paths(
+		analytics_event::analytics_events_get,
 		analytics_get::fetch_analytics,
 		analytics_get::facets::fetch_facets,
 		analytics_get::old::playtimes_get,

packages/api-client/src/modules/index.ts

@@ -19,6 +19,7 @@ import { KyrosLogsV1Module } from './kyros/logs/v1'
 import { KyrosUploadSessionsV1Module } from './kyros/upload-sessions/v1'
 import { LabrinthVersionsV2Module, LabrinthVersionsV3Module } from './labrinth'
 import { LabrinthAffiliateInternalModule } from './labrinth/affiliate/internal'
+import { LabrinthAnalyticsInternalModule } from './labrinth/analytics/internal'
 import { LabrinthAnalyticsV3Module } from './labrinth/analytics/v3'
 import { LabrinthAttributionInternalModule } from './labrinth/attribution/internal'
 import { LabrinthAuthInternalModule } from './labrinth/auth/internal'
@@ -97,6 +98,7 @@ export const MODULE_REGISTRY = {
 	kyros_logs_v1: KyrosLogsV1Module,
 	kyros_upload_sessions_v1: KyrosUploadSessionsV1Module,
 	labrinth_affiliate_internal: LabrinthAffiliateInternalModule,
+	labrinth_analytics_internal: LabrinthAnalyticsInternalModule,
 	labrinth_analytics_v3: LabrinthAnalyticsV3Module,
 	labrinth_auth_internal: LabrinthAuthInternalModule,
 	labrinth_auth_v2: LabrinthAuthV2Module,

packages/api-client/src/modules/labrinth/analytics/internal.ts

@@ -0,0 +1,51 @@
+import { AbstractModule } from '../../../core/abstract-module'
+import type { Labrinth } from '../types'
+
+export class LabrinthAnalyticsInternalModule extends AbstractModule {
+	public getModuleID(): string {
+		return 'labrinth_analytics_internal'
+	}
+
+	/**
+	 * Create an analytics event.
+	 * POST /_internal/analytics-event
+	 */
+	public async createEvent(
+		data: Labrinth.Analytics.Internal.AnalyticsEventUpsert,
+	): Promise<Labrinth.Analytics.v3.AnalyticsEvent> {
+		return this.client.request<Labrinth.Analytics.v3.AnalyticsEvent>('/analytics-event', {
+			api: 'labrinth',
+			version: 'internal',
+			method: 'POST',
+			body: data,
+		})
+	}
+
+	/**
+	 * Edit an analytics event.
+	 * PATCH /_internal/analytics-event/{id}
+	 */
+	public async editEvent(
+		id: Labrinth.Analytics.v3.AnalyticsEventId,
+		data: Labrinth.Analytics.Internal.AnalyticsEventUpsert,
+	): Promise<Labrinth.Analytics.v3.AnalyticsEvent> {
+		return this.client.request<Labrinth.Analytics.v3.AnalyticsEvent>(`/analytics-event/${id}`, {
+			api: 'labrinth',
+			version: 'internal',
+			method: 'PATCH',
+			body: data,
+		})
+	}
+
+	/**
+	 * Delete an analytics event.
+	 * DELETE /_internal/analytics-event/{id}
+	 */
+	public async deleteEvent(id: Labrinth.Analytics.v3.AnalyticsEventId): Promise<void> {
+		return this.client.request<void>(`/analytics-event/${id}`, {
+			api: 'labrinth',
+			version: 'internal',
+			method: 'DELETE',
+		})
+	}
+}

packages/api-client/src/modules/labrinth/analytics/v3.ts

@@ -70,47 +70,4 @@ export class LabrinthAnalyticsV3Module extends AbstractModule {
 			method: 'GET',
 		})
 	}
-
-	/**
-	 * Create an analytics event.
-	 * POST /v3/analytics-event
-	 */
-	public async createEvent(
-		data: Labrinth.Analytics.v3.AnalyticsEventUpsert,
-	): Promise<Labrinth.Analytics.v3.AnalyticsEvent> {
-		return this.client.request<Labrinth.Analytics.v3.AnalyticsEvent>('/analytics-event', {
-			api: 'labrinth',
-			version: 3,
-			method: 'POST',
-			body: data,
-		})
-	}
-
-	/**
-	 * Edit an analytics event.
-	 * PATCH /v3/analytics-event/{id}
-	 */
-	public async editEvent(
-		id: Labrinth.Analytics.v3.AnalyticsEventId,
-		data: Labrinth.Analytics.v3.AnalyticsEventUpsert,
-	): Promise<Labrinth.Analytics.v3.AnalyticsEvent> {
-		return this.client.request<Labrinth.Analytics.v3.AnalyticsEvent>(`/analytics-event/${id}`, {
-			api: 'labrinth',
-			version: 3,
-			method: 'PATCH',
-			body: data,
-		})
-	}
-
-	/**
-	 * Delete an analytics event.
-	 * DELETE /v3/analytics-event/{id}
-	 */
-	public async deleteEvent(id: Labrinth.Analytics.v3.AnalyticsEventId): Promise<void> {
-		return this.client.request<void>(`/analytics-event/${id}`, {
-			api: 'labrinth',
-			version: 3,
-			method: 'DELETE',
-		})
-	}
 }

packages/api-client/src/modules/labrinth/index.ts

@@ -1,3 +1,4 @@
+export * from './analytics/internal'
 export * from './analytics/v3'
 export * from './attribution/internal'
 export * from './auth/internal'

packages/api-client/src/modules/labrinth/types.ts

@@ -463,6 +463,16 @@ export namespace Labrinth {
 	}
 
 	export namespace Analytics {
+		export namespace Internal {
+			export type AnalyticsEventUpsert = {
+				announcement_url: string | null
+				for_metric_kind: v3.AnalyticsEventMetricKind[] | null
+				title: string
+				ends: string
+				starts: string
+			}
+		}
+
 		export namespace v3 {
 			export type AnalyticsEventId = number
 			export type AnalyticsEventMetricKind = 'views' | 'revenue' | 'downloads' | 'playtime'
@@ -476,14 +486,6 @@ export namespace Labrinth {
 				starts: string
 			}
 
-			export type AnalyticsEventUpsert = {
-				announcement_url: string | null
-				for_metric_kind: AnalyticsEventMetricKind[] | null
-				title: string
-				ends: string
-				starts: string
-			}
-
 			export type FetchRequest = {
 				time_range: TimeRange
 				return_metrics: ReturnMetrics