ordinary-api 0.6.0-pre.13

// Copyright (C) 2026 Ordinary Labs, LLC.
//
// SPDX-License-Identifier: AGPL-3.0-only

use axum::body::Bytes;
use axum::extract::{Query, State};
use axum::http::{HeaderMap, StatusCode};
use axum::response::IntoResponse;

use crate::server::APPLICATION;
use serde::Deserialize;
use std::sync::Arc;
use tracing::Instrument;
use utoipa::IntoParams;

#[derive(Deserialize, IntoParams)]
pub struct Params {
    /// project domain
    d: String,
    /// relative path of asset from `assets_dir`
    p: String,
}

#[utoipa::path(
    put,
    path = "/assets",
    tag = APPLICATION,
    request_body(content = [u8], content_type = "application/octet-stream"),
    params(Params),
    responses(
        (status = 401, description = "unauthorized for operation"),
        (status = 200, description = "write an asset for an application"),
    ),
    security(
        ("access" = []),
    ),
)]
pub async fn write(
    State(state): State<Arc<crate::server::OrdinaryApiServerState>>,
    Query(Params { d, p }): Query<Params>,
    headers: HeaderMap,
    body: Bytes,
) -> impl IntoResponse {
    let domain = d;
    let path = p;

    let span = tracing::info_span!("app", %domain);
    let span = span.in_scope(|| tracing::info_span!("assets", path = %path));
    let span = span.in_scope(|| tracing::info_span!("write"));

    async {
        match crate::server::check_ordinary_auth(&state, &headers, 2, &domain) {
            Ok(account) => account,
            Err(code) => return code.into_response(),
        };

        tracing::info!("writing");

        let apps = state.apps.read().await;

        if let Some(wrapped_app) = apps.get(&domain) {
            if let Err(err) = wrapped_app.app.put_asset(&path, &body).await {
                tracing::error!(%err, "failed");
            } else {
                tracing::info!("written");
                return StatusCode::OK.into_response();
            }
        }

        StatusCode::INTERNAL_SERVER_ERROR.into_response()
    }
    .instrument(span)
    .await
}