pysof 0.1.31__tar.gz → 0.1.32__tar.gz

{pysof-0.1.31 → pysof-0.1.32}/Cargo.toml

@@ -15,8 +15,8 @@ crate-type = ["cdylib"]
 
 [dependencies]
 pyo3 = { version = ">=0.24.1", features = ["extension-module", "generate-import-lib"] }
-helios-sof = { path = "../sof", version = "0.1.31" }
-helios-fhir = { path = "../fhir", version = "0.1.31" }
+helios-sof = { path = "../sof", version = "0.1.32" }
+helios-fhir = { path = "../fhir", version = "0.1.32" }
 serde = { version = "=1.0.219", features = ["derive"] }
 serde_json = { version = "=1.0.143" }
 chrono = { version = "0.4", features = ["serde"] }

{pysof-0.1.31 → pysof-0.1.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysof
-Version: 0.1.31
+Version: 0.1.32
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11

{pysof-0.1.31 → pysof-0.1.32}/crates/fhir/Cargo.toml

@@ -22,8 +22,8 @@ skip-r6-download = []
 serde = { workspace = true }
 serde_json = { workspace = true, features = ["raw_value"] }
 clap = { version = "4.0", features = ["derive"] }
-helios-fhir-macro = { path = "../fhir-macro", version = "0.1.31" }
-helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.31" }
+helios-fhir-macro = { path = "../fhir-macro", version = "0.1.32" }
+helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.32" }
 time = "0.3"
 chrono = { workspace = true }
 # Re-add serde-with-arbitrary-precision, keep macros

{pysof-0.1.31 → pysof-0.1.32}/crates/fhir-macro/Cargo.toml

@@ -19,4 +19,4 @@ proc-macro2 = "1.0"
 serde = { workspace = true }
 serde_json = { workspace = true }
 heck = "0.5" # For case conversion
-helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.31" }
+helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.32" }

{pysof-0.1.31 → pysof-0.1.32}/crates/fhirpath/Cargo.toml

@@ -17,8 +17,8 @@ R5 = ["helios-fhir/R5"]
 R6 = ["helios-fhir/R6"]
 
 [dependencies]
-helios-fhir = { path = "../fhir", version = "0.1.31" }
-helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.31" }
+helios-fhir = { path = "../fhir", version = "0.1.32" }
+helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.32" }
 chumsky = "0.10"
 roxmltree = "0.20"
 chrono = { workspace = true } # For date/time parsing and functions

{pysof-0.1.31 → pysof-0.1.32}/crates/pysof/Cargo.toml

@@ -16,8 +16,8 @@ crate-type = ["cdylib"]
 
 [dependencies]
 pyo3 = { version = ">=0.24.1", features = ["extension-module", "generate-import-lib"] }
-helios-sof = { path = "../sof", version = "0.1.31" }
-helios-fhir = { path = "../fhir", version = "0.1.31" }
+helios-sof = { path = "../sof", version = "0.1.32" }
+helios-fhir = { path = "../fhir", version = "0.1.32" }
 serde = { version = "=1.0.219", features = ["derive"] }
 serde_json = { version = "=1.0.143" }
 chrono = { version = "0.4", features = ["serde"] }

{pysof-0.1.31 → pysof-0.1.32}/crates/sof/Cargo.toml

@@ -27,9 +27,9 @@ R6 = ["helios-fhir/R6", "helios-fhirpath/R6"]
 [dependencies]
 clap = { version = "4.0", features = ["derive", "env"] }
 tokio = { version = "1.0", features = ["full"] }
-helios-fhir = { path = "../fhir", version = "0.1.31" }
-helios-fhirpath = { path = "../fhirpath", version = "0.1.31" }
-helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.31" }
+helios-fhir = { path = "../fhir", version = "0.1.32" }
+helios-fhirpath = { path = "../fhirpath", version = "0.1.32" }
+helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.32" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 csv = "1.3"

{pysof-0.1.31 → pysof-0.1.32}/crates/sof/README.md

@@ -263,7 +263,7 @@ sof-cli -v view.json -s s3://bucket/patients.ndjson -f json
 sof-cli -v view.json -s file:///data.ndjson -b additional-data.json -f csv
 
 # Server API with NDJSON
-curl -X POST "http://localhost:8080/ViewDefinition/$run?source=s3://bucket/data.ndjson" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run?source=s3://bucket/data.ndjson" \
   -H "Content-Type: application/json" \
   -d '{"resourceType": "Parameters", "parameter": [{"name": "viewResource", "resource": {...}}]}'
 ```
@@ -472,12 +472,12 @@ Returns the server's CapabilityStatement describing supported operations:
 curl http://localhost:8080/metadata
 ```
 
-##### POST /ViewDefinition/$run
+##### POST /ViewDefinition/$viewdefinition-run
 Execute a ViewDefinition transformation:
 
 ```bash
 # JSON output (default)
-curl -X POST http://localhost:8080/ViewDefinition/$run \
+curl -X POST http://localhost:8080/ViewDefinition/$viewdefinition-run \
   -H "Content-Type: application/json" \
   -d '{
     "resourceType": "Parameters",
@@ -508,17 +508,17 @@ curl -X POST http://localhost:8080/ViewDefinition/$run \
   }'
 
 # CSV output (includes headers by default)
-curl -X POST "http://localhost:8080/ViewDefinition/$run?_format=text/csv" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run?_format=text/csv" \
   -H "Content-Type: application/json" \
   -d '{...}'
 
 # CSV output without headers
-curl -X POST "http://localhost:8080/ViewDefinition/$run?_format=text/csv&header=false" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run?_format=text/csv&header=false" \
   -H "Content-Type: application/json" \
   -d '{...}'
 
 # NDJSON output
-curl -X POST http://localhost:8080/ViewDefinition/$run \
+curl -X POST http://localhost:8080/ViewDefinition/$viewdefinition-run \
   -H "Content-Type: application/json" \
   -H "Accept: application/ndjson" \
   -d '{...}'
@@ -526,7 +526,7 @@ curl -X POST http://localhost:8080/ViewDefinition/$run \
 
 #### Parameters
 
-The `$run` POST operation accepts parameters either as query parameters or in a FHIR Parameters resource.
+The `$viewdefinition-run` POST operation accepts parameters either as query parameters or in a FHIR Parameters resource.
 
 Parameter table:
 
@@ -617,17 +617,17 @@ The server automatically sets appropriate response headers based on the output f
 
 ```bash
 # Limit results - first 50 records as CSV
-curl -X POST "http://localhost:8080/ViewDefinition/$run?_limit=50&_format=text/csv" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run?_limit=50&_format=text/csv" \
   -H "Content-Type: application/json" \
   -d '{...}'
 
 # CSV without headers, limited to 20 results
-curl -X POST "http://localhost:8080/ViewDefinition/$run?_format=text/csv&header=false&_limit=20" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run?_format=text/csv&header=false&_limit=20" \
   -H "Content-Type: application/json" \
   -d '{...}'
 
 # Using header parameter in request body (overrides query params)
-curl -X POST "http://localhost:8080/ViewDefinition/$run?_format=text/csv" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run?_format=text/csv" \
   -H "Content-Type: application/json" \
   -d '{
     "resourceType": "Parameters",
@@ -641,12 +641,12 @@ curl -X POST "http://localhost:8080/ViewDefinition/$run?_format=text/csv" \
   }'
 
 # Filter by modification time (requires resources with lastUpdated metadata)
-curl -X POST "http://localhost:8080/ViewDefinition/$run?_since=2024-01-01T00:00:00Z" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run?_since=2024-01-01T00:00:00Z" \
   -H "Content-Type: application/json" \
   -d '{...}'
 
 # Load data from S3 bucket
-curl -X POST "http://localhost:8080/ViewDefinition/$run?source=s3://my-bucket/bundle.json" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run?source=s3://my-bucket/bundle.json" \
   -H "Content-Type: application/json" \
   -d '{
     "resourceType": "Parameters",
@@ -657,24 +657,24 @@ curl -X POST "http://localhost:8080/ViewDefinition/$run?source=s3://my-bucket/bu
   }'
 
 # Load data from Azure with filtering
-curl -X POST "http://localhost:8080/ViewDefinition/$run?source=azure://container/data.json&_limit=100" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run?source=azure://container/data.json&_limit=100" \
   -H "Content-Type: application/json" \
   -d '{...}'
 
 # Generate Parquet with custom compression and row group size
-curl -X POST "http://localhost:8080/ViewDefinition/$run?_format=application/parquet&compression=zstd&rowGroupSize=512" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run?_format=application/parquet&compression=zstd&rowGroupSize=512" \
   -H "Content-Type: application/json" \
   -d '{...}' \
   --output result.parquet
 
 # Generate large Parquet with file splitting (returns ZIP if multiple files)
-curl -X POST "http://localhost:8080/ViewDefinition/$run?_format=application/parquet&maxFileSize=100" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run?_format=application/parquet&maxFileSize=100" \
   -H "Content-Type: application/json" \
   -d '{...}' \
   --output result.zip
 
 # Using Parquet parameters in request body
-curl -X POST "http://localhost:8080/ViewDefinition/$run" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run" \
   -H "Content-Type: application/json" \
   -d '{
     "resourceType": "Parameters",
@@ -901,19 +901,19 @@ sof-cli --view view.json --bundle large-data.json --format parquet \
 #          output_003.parquet (remaining data)
 
 # Server API - single Parquet file
-curl -X POST "http://localhost:8080/ViewDefinition/$run?_format=application/parquet" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run?_format=application/parquet" \
   -H "Content-Type: application/json" \
   -d '{"resourceType": "Parameters", ...}' \
   --output result.parquet
 
 # Server API - with file splitting (returns ZIP archive if multiple files)
-curl -X POST "http://localhost:8080/ViewDefinition/$run?_format=application/parquet&maxFileSize=100" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run?_format=application/parquet&maxFileSize=100" \
   -H "Content-Type: application/json" \
   -d '{"resourceType": "Parameters", ...}' \
   --output result.zip
 
 # Server API - optimized settings for large datasets
-curl -X POST "http://localhost:8080/ViewDefinition/$run?_format=application/parquet&compression=zstd&rowGroupSize=512&maxFileSize=500" \
+curl -X POST "http://localhost:8080/ViewDefinition/$viewdefinition-run?_format=application/parquet&compression=zstd&rowGroupSize=512&maxFileSize=500" \
   -H "Content-Type: application/json" \
   -d '{"resourceType": "Parameters", ...}' \
   --output result.zip

{pysof-0.1.31 → pysof-0.1.32}/crates/sof/src/cli.rs

@@ -276,7 +276,19 @@ fn normalize_source_path(source: &str) -> Result<String, Box<dyn std::error::Err
         .unwrap_or_else(|_| absolute_path.clone());
 
     // Convert to file:// URL
-    Ok(format!("file://{}", canonical_path.display()))
+    // On Windows, paths like C:\foo need to become file:///C:/foo
+    // On Unix, paths like /foo become file:///foo
+    #[cfg(windows)]
+    let url = {
+        let path_str = canonical_path.to_string_lossy();
+        // Replace backslashes with forward slashes for URL format
+        let normalized = path_str.replace('\\', "/");
+        format!("file:///{}", normalized)
+    };
+    #[cfg(not(windows))]
+    let url = format!("file://{}", canonical_path.display());
+
+    Ok(url)
 }
 
 /// Main entry point for the SQL-on-FHIR CLI application.
@@ -774,20 +786,40 @@ mod tests {
     #[test]
     fn test_normalize_source_path_absolute_path() {
         // Absolute paths should be converted to file:// URLs
-        let result = normalize_source_path("/tmp/test.json").unwrap();
-        assert!(result.starts_with("file:///"));
-        assert!(result.contains("/tmp/test.json") || result.contains("private/tmp/test.json"));
+        // Use a platform-appropriate absolute path
+        #[cfg(windows)]
+        let test_path = "C:\\tmp\\test.json";
+        #[cfg(not(windows))]
+        let test_path = "/tmp/test.json";
+
+        let result = normalize_source_path(test_path).unwrap();
+        assert!(
+            result.starts_with("file:///"),
+            "Expected file:/// prefix, got: {}",
+            result
+        );
+        // On macOS, /tmp may be symlinked to /private/tmp
+        assert!(
+            result.contains("tmp") && result.contains("test.json"),
+            "Expected path to contain tmp and test.json, got: {}",
+            result
+        );
     }
 
     #[test]
     fn test_normalize_source_path_relative_path() {
         // Relative paths should be converted to absolute file:// URLs
         let result = normalize_source_path("./test.json").unwrap();
-        assert!(result.starts_with("file:///"));
-        // Should contain the current working directory
-        let cwd = std::env::current_dir().unwrap();
         assert!(
-            result.contains(&cwd.to_string_lossy().to_string()) || result.starts_with("file:///")
+            result.starts_with("file:///"),
+            "Expected file:/// prefix, got: {}",
+            result
+        );
+        // Should contain test.json somewhere in the path
+        assert!(
+            result.contains("test.json"),
+            "Expected path to contain test.json, got: {}",
+            result
         );
     }
 }

{pysof-0.1.31 → pysof-0.1.32}/crates/sof/src/handlers.rs

@@ -1,7 +1,7 @@
 //! Request handlers for the SQL-on-FHIR server
 //!
 //! This module implements the HTTP request handlers for all server endpoints,
-//! including the CapabilityStatement and ViewDefinition/$run operations.
+//! including the CapabilityStatement and ViewDefinition/$viewdefinition-run operations.
 
 use axum::{
     Json,
@@ -39,9 +39,9 @@ pub async fn capability_statement() -> ServerResult<impl IntoResponse> {
     ))
 }
 
-/// Handler for POST /ViewDefinition/$run - executes a ViewDefinition
+/// Handler for POST /ViewDefinition/$viewdefinition-run - executes a ViewDefinition
 ///
-/// The `$run` operation on a ViewDefinition resource applies the view definition to
+/// The `$viewdefinition-run` operation on a ViewDefinition resource applies the view definition to
 /// transform FHIR resources into a tabular format and returns the results synchronously.
 ///
 /// # Arguments
@@ -78,7 +78,7 @@ pub async fn run_view_definition_handler(
     headers: HeaderMap,
     Json(body): Json<serde_json::Value>,
 ) -> ServerResult<Response> {
-    info!("Handling ViewDefinition/$run request");
+    info!("Handling ViewDefinition/$viewdefinition-run request");
     debug!("Query params: {:?}", params);
 
     // Validate and parse query parameters
@@ -105,8 +105,6 @@ pub async fn run_view_definition_handler(
         ));
     }
 
-    // Source parameter is now handled below
-
     // For backward compatibility, extract the legacy tuple format
     let view_def_json = extracted_params.view_definition;
     let resources_json = if extracted_params.resources.is_empty() {
@@ -155,9 +153,6 @@ pub async fn run_view_definition_handler(
         validated_params.format = content_type;
     }
 
-    // Create ViewDefinition
-    let view_definition = parse_view_definition(view_def_json)?;
-
     // Apply patient and group filters from body parameters to resources if provided
     let mut filtered_resources = resources_json.unwrap_or_default();
 
@@ -220,14 +215,23 @@ pub async fn run_view_definition_handler(
     }
 
     // Handle source parameter - load data from external source if provided
+    // IMPORTANT: We load the source bundle FIRST so we can determine its FHIR version
+    // and parse the ViewDefinition using the same version
     let mut source_bundle = None;
+    let mut source_fhir_version = None;
     if let Some(source) = &source_param {
         info!("Loading data from source: {}", source);
         let data_source = UniversalDataSource::new();
-        let mut loaded_bundle = data_source.load(source).await?;
+        let loaded_bundle = data_source.load(source).await?;
+
+        // Capture the FHIR version from the loaded source bundle
+        source_fhir_version = Some(loaded_bundle.version());
 
         // Apply filters to source bundle if needed
-        if patient_filter.is_some() || group_filter.is_some() || validated_params.since.is_some() {
+        let loaded_bundle = if patient_filter.is_some()
+            || group_filter.is_some()
+            || validated_params.since.is_some()
+        {
             // Extract resources from source bundle for filtering
             let mut source_resources = extract_resources_from_bundle(&loaded_bundle)?;
 
@@ -244,13 +248,30 @@ pub async fn run_view_definition_handler(
                 source_resources = filter_resources_by_since(source_resources, since)?;
             }
 
-            // Recreate bundle with filtered resources
-            loaded_bundle = create_bundle_from_resources(source_resources)?;
-        }
+            // Recreate bundle with filtered resources using the same FHIR version
+            create_bundle_from_resources_for_version(
+                source_resources,
+                source_fhir_version.unwrap(),
+            )?
+        } else {
+            loaded_bundle
+        };
 
         source_bundle = Some(loaded_bundle);
     }
 
+    // Create ViewDefinition - use the source bundle's version if available,
+    // otherwise use the default (newest enabled) version
+    let view_definition = if let Some(version) = source_fhir_version {
+        info!(
+            "Parsing ViewDefinition as {:?} (matching source bundle)",
+            version
+        );
+        parse_view_definition_for_version(view_def_json, version)?
+    } else {
+        parse_view_definition(view_def_json)?
+    };
+
     // Apply filters to provided resources
     if patient_filter.is_some() || group_filter.is_some() {
         filtered_resources = filter_resources_by_patient_and_group(
@@ -400,9 +421,9 @@ fn create_capability_statement() -> serde_json::Value {
         "rest": [{
             "mode": "server",
             "operation": [{
-                "name": "run",
-                "definition": "http://sql-on-fhir.org/OperationDefinition/ViewDefinition-run",
-                "documentation": "Execute a ViewDefinition to transform FHIR resources into tabular format. Supports CSV, JSON, and NDJSON output formats. This is a type-level operation invoked at /ViewDefinition/$run"
+                "name": "viewdefinition-run",
+                "definition": "http://sql-on-fhir.org/OperationDefinition/$viewdefinition-run",
+                "documentation": "Execute a ViewDefinition to transform FHIR resources into tabular format. Supports CSV, JSON, and NDJSON output formats. This is a type-level operation invoked at /ViewDefinition/$viewdefinition-run"
             }]
         }]
     })
@@ -454,11 +475,17 @@ fn resolve_view_reference(reference: &str) -> ServerResult<SofViewDefinition> {
     )))
 }
 
-/// Parse a ViewDefinition from JSON
+/// Parse a ViewDefinition from JSON using the newest enabled FHIR version
 fn parse_view_definition(json: serde_json::Value) -> ServerResult<SofViewDefinition> {
-    let newest_version = get_newest_enabled_fhir_version();
+    parse_view_definition_for_version(json, get_newest_enabled_fhir_version())
+}
 
-    match newest_version {
+/// Parse a ViewDefinition from JSON using a specific FHIR version
+fn parse_view_definition_for_version(
+    json: serde_json::Value,
+    version: helios_fhir::FhirVersion,
+) -> ServerResult<SofViewDefinition> {
+    match version {
         #[cfg(feature = "R4")]
         helios_fhir::FhirVersion::R4 => {
             let view_def: helios_fhir::r4::ViewDefinition =
@@ -539,10 +566,16 @@ fn parse_parameters(json: serde_json::Value) -> ServerResult<RunParameters> {
     }
 }
 
-/// Create a Bundle from a list of resources
+/// Create a Bundle from a list of resources using the newest enabled FHIR version
 fn create_bundle_from_resources(resources: Vec<serde_json::Value>) -> ServerResult<SofBundle> {
-    let newest_version = get_newest_enabled_fhir_version();
+    create_bundle_from_resources_for_version(resources, get_newest_enabled_fhir_version())
+}
 
+/// Create a Bundle from a list of resources using a specific FHIR version
+fn create_bundle_from_resources_for_version(
+    resources: Vec<serde_json::Value>,
+    version: helios_fhir::FhirVersion,
+) -> ServerResult<SofBundle> {
     let bundle_json = serde_json::json!({
         "resourceType": "Bundle",
         "type": "collection",
@@ -553,7 +586,7 @@ fn create_bundle_from_resources(resources: Vec<serde_json::Value>) -> ServerResu
         }).collect::<Vec<_>>()
     });
 
-    match newest_version {
+    match version {
         #[cfg(feature = "R4")]
         helios_fhir::FhirVersion::R4 => {
             let bundle: helios_fhir::r4::Bundle =
@@ -700,7 +733,7 @@ fn merge_bundles(
 /// Filter resources by patient and/or group reference
 ///
 /// This function implements the patient and group filtering as specified in the
-/// SQL-on-FHIR $run operation:
+/// SQL-on-FHIR $viewdefinition-run operation:
 ///
 /// - **Patient filter**: Returns only resources in the patient compartment of specified patients
 /// - **Group filter**: Returns only resources that are members of the specified group
@@ -868,7 +901,7 @@ mod tests {
         // Check that operation is listed at rest level (type-level operation)
         let operations = &cap_stmt["rest"][0]["operation"];
         assert!(operations.as_array().is_some());
-        assert_eq!(operations[0]["name"], "run");
+        assert_eq!(operations[0]["name"], "viewdefinition-run");
     }
 
     #[test]

{pysof-0.1.31 → pysof-0.1.32}/crates/sof/src/models.rs

@@ -8,7 +8,7 @@ use helios_sof::{ContentType, SofParameters};
 use serde::Deserialize;
 use tracing::debug;
 
-/// Query parameters for ViewDefinition/$run endpoint
+/// Query parameters for ViewDefinition/$viewdefinition-run endpoint
 #[derive(Debug, Deserialize)]
 pub struct RunQueryParams {
     /// Output format override (alternative to Accept header)
@@ -89,7 +89,7 @@ pub struct ValidatedRunParams {
     pub parquet_options: Option<helios_sof::ParquetOptions>,
 }
 
-/// Parameters for ViewDefinition/$run operation - now using proper FHIR Parameters
+/// Parameters for ViewDefinition/$viewdefinition-run operation - now using proper FHIR Parameters
 pub type RunParameters = SofParameters;
 
 /// Validate and parse query parameters into structured format

{pysof-0.1.31 → pysof-0.1.32}/crates/sof/src/server.rs

@@ -26,7 +26,7 @@
 //! GET /metadata
 //!   Returns: CapabilityStatement
 //!
-//! POST /ViewDefinition/$run
+//! POST /ViewDefinition/$viewdefinition-run
 //!   Body: Parameters resource containing ViewDefinition and data
 //!   Query Parameters (except viewReference, viewResource, patient, group, resource):
 //!     _format: Output format - application/json, application/ndjson, text/csv, application/parquet
@@ -290,7 +290,7 @@ fn create_app_with_config(config: &ServerConfig) -> Router {
         // FHIR endpoints
         .route("/metadata", get(handlers::capability_statement))
         .route(
-            "/ViewDefinition/$run",
+            "/ViewDefinition/$viewdefinition-run",
             post(handlers::run_view_definition_handler),
         )
         // Health check endpoint

{pysof-0.1.31 → pysof-0.1.32}/crates/sof/tests/common/mod.rs

@@ -30,11 +30,11 @@ fn create_test_app() -> Router {
     Router::new()
         .route("/metadata", get(capability_statement_handler))
         .route(
-            "/ViewDefinition/$run",
+            "/ViewDefinition/$viewdefinition-run",
             post(run_view_definition_handler).get(run_view_definition_get_handler),
         )
         .route(
-            "/ViewDefinition/{id}/$run",
+            "/ViewDefinition/{id}/$viewdefinition-run",
             get(run_view_definition_by_id_handler),
         )
         .route("/health", get(health_check))
@@ -70,14 +70,14 @@ async fn capability_statement_handler() -> axum::response::Response {
             "resource": [{
                 "type": "ViewDefinition",
                 "operation": [{
-                    "name": "run",
-                    "definition": "http://sql-on-fhir.org/OperationDefinition/ViewDefinition-run",
+                    "name": "viewdefinition-run",
+                    "definition": "http://sql-on-fhir.org/OperationDefinition/$viewdefinition-run",
                     "documentation": "Execute a ViewDefinition to transform FHIR resources into tabular format"
                 }]
             }],
             "operation": [{
-                "name": "run",
-                "definition": "http://sql-on-fhir.org/OperationDefinition/ViewDefinition-run",
+                "name": "viewdefinition-run",
+                "definition": "http://sql-on-fhir.org/OperationDefinition/$viewdefinition-run",
                 "documentation": "Execute a ViewDefinition to transform FHIR resources into tabular format. Supports CSV, JSON, and NDJSON output formats."
             }]
         }]
@@ -546,7 +546,7 @@ async fn run_view_definition_get_handler(
     // For GET requests without a ViewDefinition, we cannot proceed
     error_response(
         axum::http::StatusCode::BAD_REQUEST,
-        "GET /ViewDefinition/$run requires a ViewDefinition to be provided. Since complex parameters cannot be used in GET requests, please use POST with viewResource or viewReference parameter.",
+        "GET /ViewDefinition/$viewdefinition-run requires a ViewDefinition to be provided. Since complex parameters cannot be used in GET requests, please use POST with viewResource or viewReference parameter.",
     )
 }
 
@@ -558,7 +558,7 @@ async fn run_view_definition_by_id_handler(
     error_response(
         axum::http::StatusCode::NOT_IMPLEMENTED,
         &format!(
-            "ViewDefinition lookup by ID '{}' is not implemented. Use POST /ViewDefinition/$run with the ViewDefinition in the request body.",
+            "ViewDefinition lookup by ID '{}' is not implemented. Use POST /ViewDefinition/$viewdefinition-run with the ViewDefinition in the request body.",
             id
         ),
     )