Add field endpoint

crates/pile-client/src/lib.rs

@@ -79,11 +79,9 @@ impl PileClient {
 
 	/// `GET /datasets` — list all datasets served by this server.
 	pub async fn list_datasets(&self) -> Result<Vec<DatasetInfo>, ClientError> {
-		let resp = self
+		let url = format!("{}/datasets", self.base_url);
-			.client
+		trace!(url, "GET /datasets");
-			.get(format!("{}/datasets", self.base_url))
+		let resp = self.client.get(url).send().await?;
-			.send()
-			.await?;
 
 		check_status(resp).await?.json().await.map_err(Into::into)
 	}
@@ -112,12 +110,9 @@ impl DatasetClient {
 			limit,
 		};
 
-		let resp = self
+		let url = format!("{}/lookup", self.base_url);
-			.client
+		trace!(url, "POST /lookup");
-			.post(format!("{}/lookup", self.base_url))
+		let resp = self.client.post(url).json(&body).send().await?;
-			.json(&body)
-			.send()
-			.await?;
 
 		check_status(resp).await?.json().await.map_err(Into::into)
 	}
@@ -130,9 +125,11 @@ impl DatasetClient {
 		source: &str,
 		key: &str,
 	) -> Result<Pin<Box<dyn Stream<Item = Result<Bytes, reqwest::Error>> + Send>>, ClientError> {
+		let url = format!("{}/item", self.base_url);
+		trace!(url, source, key, "GET /item");
 		let resp = self
 			.client
-			.get(format!("{}/item", self.base_url))
+			.get(url)
 			.query(&[("source", source), ("key", key)])
 			.send()
 			.await?;
@@ -140,16 +137,18 @@ impl DatasetClient {
 		Ok(Box::pin(check_status(resp).await?.bytes_stream()))
 	}
 
-	/// `GET /field` — extract a field from an item by object path (e.g. `$.flac.title`).
+	/// `GET /extract` — extract a field from an item by object path (e.g. `$.flac.title`).
-	pub async fn get_field(
+	pub async fn get_extract(
 		&self,
 		source: &str,
 		key: &str,
 		path: &str,
 	) -> Result<FieldResponse, ClientError> {
+		let url = format!("{}/extract", self.base_url);
+		trace!(url, source, key, path, "GET /extract");
 		let resp = self
 			.client
-			.get(format!("{}/field", self.base_url))
+			.get(url)
 			.query(&[("source", source), ("key", key), ("path", path)])
 			.send()
 			.await?;
@@ -168,15 +167,47 @@ impl DatasetClient {
 		Ok(FieldResponse { content_type, data })
 	}
 
+	/// `GET /field` — get a field from an item's schema
+	pub async fn get_field(
+		&self,
+		source: &str,
+		key: &str,
+		field: &str,
+	) -> Result<FieldResponse, ClientError> {
+		let url = format!("{}/field", self.base_url);
+		trace!(url, source, key, field, "GET /field");
+		let resp = self
+			.client
+			.get(url)
+			.query(&[("source", source), ("key", key), ("field", field)])
+			.send()
+			.await?;
+
+		let resp = check_status(resp).await?;
+
+		let content_type = resp
+			.headers()
+			.get(header::CONTENT_TYPE)
+			.and_then(|v| v.to_str().ok())
+			.unwrap_or("application/octet-stream")
+			.to_owned();
+
+		let data = resp.bytes().await?;
+
+		Ok(FieldResponse { content_type, data })
+	}
+
 	/// `GET /items` — paginate over all items in this dataset, ordered by (source, key).
 	pub async fn list_items(
 		&self,
 		offset: usize,
 		limit: usize,
 	) -> Result<ItemsResponse, ClientError> {
+		let url = format!("{}/items", self.base_url);
+		trace!(url, offset, limit, "GET /items");
 		let resp = self
 			.client
-			.get(format!("{}/items", self.base_url))
+			.get(url)
 			.query(&[("offset", offset), ("limit", limit)])
 			.send()
 			.await?;

crates/pile-config/src/lib.rs

@@ -96,19 +96,10 @@ pub enum Source {
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct FieldSpec {
-	/// The type of this field
-	pub r#type: FieldType,
-
 	/// How to find this field in a data entry
 	pub path: Vec<ObjectPath>,
 }
 
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "lowercase")]
-pub enum FieldType {
-	Text,
-}
-
 //
 // MARK: fts
 //

crates/pile-dataset/src/serve/extract.rs

@@ -0,0 +1,150 @@
+use axum::{
+	Json,
+	extract::{Query, RawQuery, State},
+	http::{StatusCode, header},
+	response::{IntoResponse, Response},
+};
+use pile_config::{Label, objectpath::ObjectPath};
+use pile_value::{extract::traits::ExtractState, value::PileValue};
+use serde::Deserialize;
+use std::{sync::Arc, time::Instant};
+use tracing::debug;
+use utoipa::ToSchema;
+
+use crate::Datasets;
+
+#[derive(Deserialize, ToSchema)]
+pub struct ExtractQuery {
+	source: String,
+	key: String,
+
+	#[serde(default)]
+	download: bool,
+}
+
+/// Extract a specific field from an item's metadata.
+/// Multiple `path` parameters may be provided; the first non-null result is returned.
+#[utoipa::path(
+	get,
+	path = "/extract",
+	params(
+		("source" = String, Query, description = "Source label"),
+		("key" = String, Query, description = "Item key"),
+		("path" = String, Query, description = "Object path (e.g. $.flac.title); repeat for fallbacks"),
+	),
+	responses(
+		(status = 200, description = "Field value as JSON"),
+		(status = 400, description = "Invalid source label or path"),
+		(status = 404, description = "Item or field not found"),
+		(status = 500, description = "Internal server error"),
+	)
+)]
+pub async fn get_extract(
+	State(state): State<Arc<Datasets>>,
+	Query(params): Query<ExtractQuery>,
+	RawQuery(raw_query): RawQuery,
+) -> Response {
+	let start = Instant::now();
+
+	let label = match Label::try_from(params.source.clone()) {
+		Ok(l) => l,
+		Err(e) => return (StatusCode::BAD_REQUEST, format!("{e:?}")).into_response(),
+	};
+
+	// Collect all `path` query params in order (supports repeated ?path=...&path=...)
+	let raw = raw_query.as_deref().unwrap_or("");
+	let paths: Vec<ObjectPath> = {
+		let mut result = Vec::new();
+		for part in raw.split('&') {
+			if let Some((k, v)) = part.split_once('=')
+				&& k == "path"
+			{
+				match v.parse::<ObjectPath>() {
+					Ok(p) => result.push(p),
+					Err(e) => {
+						return (StatusCode::BAD_REQUEST, format!("{e:?}")).into_response();
+					}
+				}
+			}
+		}
+		result
+	};
+
+	if paths.is_empty() {
+		return (StatusCode::BAD_REQUEST, "Missing `path` query parameter").into_response();
+	}
+
+	debug!(
+		message = "Serving /extract",
+		source = params.source,
+		key = params.key,
+		paths = paths.len(),
+	);
+
+	let Some(item) = state.get(&label, &params.key).await else {
+		return StatusCode::NOT_FOUND.into_response();
+	};
+
+	let extract_state = ExtractState { ignore_mime: false };
+	let item = PileValue::Item(item);
+
+	// Try each path in order, returning the first non-null result
+	let mut value = None;
+	for path in &paths {
+		match item.query(&extract_state, path).await {
+			Ok(Some(PileValue::Null)) | Ok(None) => continue,
+			Ok(Some(v)) => {
+				value = Some(v);
+				break;
+			}
+			Err(e) => return (StatusCode::INTERNAL_SERVER_ERROR, format!("{e:?}")).into_response(),
+		}
+	}
+
+	let Some(value) = value else {
+		return StatusCode::NOT_FOUND.into_response();
+	};
+
+	debug!(
+		message = "Served /extract",
+		source = params.source,
+		key = params.key,
+		time_ms = start.elapsed().as_millis()
+	);
+
+	let disposition = if params.download {
+		"attachment"
+	} else {
+		"inline"
+	};
+
+	match value {
+		PileValue::String(s) => (
+			StatusCode::OK,
+			[
+				(header::CONTENT_TYPE, "text/plain".to_owned()),
+				(header::CONTENT_DISPOSITION, disposition.to_owned()),
+			],
+			s.to_string(),
+		)
+			.into_response(),
+		PileValue::Blob { mime, bytes } => (
+			StatusCode::OK,
+			[
+				(header::CONTENT_TYPE, mime.to_string()),
+				(header::CONTENT_DISPOSITION, disposition.to_owned()),
+			],
+			bytes.as_ref().clone(),
+		)
+			.into_response(),
+		_ => match value.to_json(&extract_state).await {
+			Ok(json) => (
+				StatusCode::OK,
+				[(header::CONTENT_DISPOSITION, disposition.to_owned())],
+				Json(json),
+			)
+				.into_response(),
+			Err(e) => (StatusCode::INTERNAL_SERVER_ERROR, format!("{e:?}")).into_response(),
+		},
+	}
+}

crates/pile-dataset/src/serve/field.rs

@@ -1,35 +1,36 @@
 use axum::{
 	Json,
-	extract::{Query, RawQuery, State},
+	extract::{Query, State},
 	http::{StatusCode, header},
 	response::{IntoResponse, Response},
 };
-use pile_config::{Label, objectpath::ObjectPath};
+use pile_config::Label;
 use pile_value::{extract::traits::ExtractState, value::PileValue};
 use serde::Deserialize;
 use std::{sync::Arc, time::Instant};
 use tracing::debug;
-use utoipa::ToSchema;
+use utoipa::{IntoParams, ToSchema};
 
 use crate::Datasets;
 
-#[derive(Deserialize, ToSchema)]
+#[derive(Deserialize, ToSchema, IntoParams)]
 pub struct FieldQuery {
 	source: String,
 	key: String,
+	field: String,
+
 	#[serde(default)]
 	download: bool,
 }
 
 /// Extract a specific field from an item's metadata.
-/// Multiple `path` parameters may be provided; the first non-null result is returned.
 #[utoipa::path(
 	get,
 	path = "/field",
 	params(
 		("source" = String, Query, description = "Source label"),
 		("key" = String, Query, description = "Item key"),
-		("path" = String, Query, description = "Object path (e.g. $.flac.title); repeat for fallbacks"),
+		("field" = String, Query, description = "Schema field"),
 	),
 	responses(
 		(status = 200, description = "Field value as JSON"),
@@ -41,7 +42,6 @@ pub struct FieldQuery {
 pub async fn get_field(
 	State(state): State<Arc<Datasets>>,
 	Query(params): Query<FieldQuery>,
-	RawQuery(raw_query): RawQuery,
 ) -> Response {
 	let start = Instant::now();
 
@@ -50,46 +50,32 @@ pub async fn get_field(
 		Err(e) => return (StatusCode::BAD_REQUEST, format!("{e:?}")).into_response(),
 	};
 
-	// Collect all `path` query params in order (supports repeated ?path=...&path=...)
-	let raw = raw_query.as_deref().unwrap_or("");
-	let paths: Vec<ObjectPath> = {
-		let mut result = Vec::new();
-		for part in raw.split('&') {
-			if let Some((k, v)) = part.split_once('=')
-				&& k == "path"
-			{
-				match v.parse::<ObjectPath>() {
-					Ok(p) => result.push(p),
-					Err(e) => {
-						return (StatusCode::BAD_REQUEST, format!("{e:?}")).into_response();
-					}
-				}
-			}
-		}
-		result
-	};
-
-	if paths.is_empty() {
-		return (StatusCode::BAD_REQUEST, "Missing `path` query parameter").into_response();
-	}
-
 	debug!(
 		message = "Serving /field",
 		source = params.source,
 		key = params.key,
-		paths = paths.len(),
+		field = params.field,
 	);
 
 	let Some(item) = state.get(&label, &params.key).await else {
 		return StatusCode::NOT_FOUND.into_response();
 	};
 
+	let field = match Label::new(&params.field) {
+		Some(x) => x,
+		None => return StatusCode::NOT_FOUND.into_response(),
+	};
+
+	let paths = match state.config.schema.get(&field) {
+		Some(x) => &x.path,
+		None => return StatusCode::NOT_FOUND.into_response(),
+	};
+
 	let extract_state = ExtractState { ignore_mime: false };
 	let item = PileValue::Item(item);
 
-	// Try each path in order, returning the first non-null result
 	let mut value = None;
-	for path in &paths {
+	for path in paths {
 		match item.query(&extract_state, path).await {
 			Ok(Some(PileValue::Null)) | Ok(None) => continue,
 			Ok(Some(v)) => {
@@ -108,6 +94,7 @@ pub async fn get_field(
 		message = "Served /field",
 		source = params.source,
 		key = params.key,
+		field = params.field,
 		time_ms = start.elapsed().as_millis()
 	);
 

crates/pile-dataset/src/serve/mod.rs

@@ -14,6 +14,9 @@ pub use lookup::*;
 mod item;
 pub use item::*;
 
+mod extract;
+pub use extract::*;
+
 mod field;
 pub use field::*;
 
@@ -23,12 +26,13 @@ pub use items::*;
 #[derive(OpenApi)]
 #[openapi(
 	tags(),
-	paths(lookup, item_get, get_field, items_list),
+	paths(lookup, item_get, get_extract, items_list, get_field),
 	components(schemas(
 		LookupRequest,
 		LookupResponse,
 		LookupResult,
 		ItemQuery,
+		ExtractQuery,
 		FieldQuery,
 		ItemsQuery,
 		ItemsResponse,
@@ -48,6 +52,7 @@ impl Datasets {
 		let mut router = Router::new()
 			.route("/lookup", post(lookup))
 			.route("/item", get(item_get))
+			.route("/extract", get(get_extract))
 			.route("/field", get(get_field))
 			.route("/items", get(items_list))
 			.with_state(self.clone());

crates/pile/src/command/server.rs

@@ -173,7 +173,7 @@ pub struct ListDatasetsResponse {
 /// List all datasets served by this server
 #[utoipa::path(
 	get,
-	path = "/list_datasets",
+	path = "/datasets",
 	responses(
 		(status = 200, description = "List of datasets"),
 		(status = 500, description = "Internal server error"),