refactor: remove loco-rs deps

apps/recorder/src/web/controller/oidc/callback.tsx

@@ -0,0 +1,32 @@
+import { createFileRoute, redirect } from '@tanstack/react-router';
+import { EventTypes } from 'oidc-client-rx';
+import { useAuth } from '../../../auth/hooks';
+
+export const Route = createFileRoute('/oidc/callback')({
+  component: RouteComponent,
+  beforeLoad: ({ context }) => {
+    if (!context.oidcSecurityService) {
+      throw redirect({
+        to: '/',
+      });
+    }
+  },
+});
+
+function RouteComponent() {
+  const auth = useAuth();
+
+  if (!auth.checkAuthResultEvent) {
+    return <div>Loading...</div>;
+  }
+
+  return (
+    <div>
+      OpenID Connect Auth Callback:{' '}
+      {auth.checkAuthResultEvent?.type ===
+      EventTypes.CheckingAuthFinishedWithError
+        ? auth.checkAuthResultEvent.value
+        : 'success'}
+    </div>
+  );
+}

apps/recorder/src/web/controller/oidc/mod.rs

@@ -0,0 +1,79 @@
+use std::sync::Arc;
+
+use axum::{
+    Json, Router,
+    extract::{Query, State},
+    http::request::Parts,
+    routing::get,
+};
+
+use super::core::Controller;
+use crate::{
+    app::AppContext,
+    auth::{
+        AuthError, AuthService, AuthServiceTrait,
+        oidc::{OidcAuthCallbackPayload, OidcAuthCallbackQuery, OidcAuthRequest},
+    },
+    errors::RResult,
+    extract::http::ForwardedRelatedInfo,
+    models::auth::AuthType,
+};
+
+pub const CONTROLLER_PREFIX: &str = "/api/oidc";
+
+async fn oidc_callback(
+    State(ctx): State<Arc<AppContext>>,
+    Query(query): Query<OidcAuthCallbackQuery>,
+) -> Result<Json<OidcAuthCallbackPayload>, AuthError> {
+    let auth_service = &ctx.auth;
+    if let AuthService::Oidc(oidc_auth_service) = auth_service {
+        let response = oidc_auth_service
+            .extract_authorization_request_callback(query)
+            .await?;
+        Ok(Json(response))
+    } else {
+        Err(AuthError::NotSupportAuthMethod {
+            supported: vec![auth_service.auth_type()],
+            current: AuthType::Oidc,
+        })
+    }
+}
+
+async fn oidc_auth(
+    State(ctx): State<Arc<AppContext>>,
+    parts: Parts,
+) -> Result<Json<OidcAuthRequest>, AuthError> {
+    let auth_service = &ctx.auth;
+    if let AuthService::Oidc(oidc_auth_service) = auth_service {
+        let mut redirect_uri = ForwardedRelatedInfo::from_request_parts(&parts)
+            .resolved_origin()
+            .ok_or_else(|| AuthError::OidcRequestRedirectUriError(url::ParseError::EmptyHost))?;
+
+        redirect_uri.set_path(&format!("{CONTROLLER_PREFIX}/callback"));
+
+        let auth_request = oidc_auth_service
+            .build_authorization_request(redirect_uri.as_str())
+            .await?;
+
+        {
+            oidc_auth_service
+                .store_authorization_request(auth_request.clone())
+                .await?;
+        }
+
+        Ok(Json(auth_request))
+    } else {
+        Err(AuthError::NotSupportAuthMethod {
+            supported: vec![auth_service.auth_type()],
+            current: AuthType::Oidc,
+        })
+    }
+}
+
+pub async fn create(_context: Arc<AppContext>) -> RResult<Controller> {
+    let router = Router::<Arc<AppContext>>::new()
+        .route("/auth", get(oidc_auth))
+        .route("/callback", get(oidc_callback));
+
+    Ok(Controller::from_prefix(CONTROLLER_PREFIX, router))
+}