Release v1.0.0

Author: yshing

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "bitmex-cli"
-version = "1.1.0"
+version = "1.0.0"
 edition = "2024"
 description = "BitMEX CLI — trade, query, and manage your BitMEX account from the terminal"
 license = "MIT"

Cargo.toml

@@ -1,41 +1,5 @@
 /// Shared helper functions used across multiple command modules.
-use serde_json::Value;
-
 use crate::errors::{BitmexError, Result};
-use crate::cli::output::CommandOutput;
-
-/// Extract a string value from a JSON object by key, returning "-" on miss.
-pub(crate) fn jstr(val: &Value, key: &str) -> String {
-    val.get(key)
-        .map(|v| match v {
-            Value::String(s) => s.clone(),
-            other => other.to_string(),
-        })
-        .unwrap_or_else(|| "-".to_string())
-}
-
-/// Parse a generic JSON value into key-value pairs for rendering.
-pub(crate) fn parse_generic(data: &Value) -> CommandOutput {
-    let pairs: Vec<(String, String)> = if let Some(obj) = data.as_object() {
-        obj.iter()
-            .map(|(k, v)| {
-                let val = match v {
-                    Value::String(s) => s.clone(),
-                    other => other.to_string(),
-                };
-                (k.clone(), val)
-            })
-            .collect()
-    } else if let Some(arr) = data.as_array() {
-        arr.iter()
-            .enumerate()
-            .map(|(i, v)| (format!("[{i}]"), v.to_string()))
-            .collect()
-    } else {
-        vec![("Result".into(), data.to_string())]
-    };
-    CommandOutput::key_value(pairs, data.clone())
-}
 
 /// Build a URL query string from (key, Option<value>) pairs, skipping None values.
 ///

src/cli/commands/helpers.rs

@@ -26,14 +26,3 @@ pub(crate) fn render_error(err: &BitmexError) {
         }
     }
 }
-
-/// Render a single NDJSON line to stdout (for WebSocket streaming).
-pub(crate) fn render_ndjson(data: &serde_json::Value) {
-    match serde_json::to_string(data) {
-        Ok(s) => println!("{s}"),
-        Err(e) => {
-            eprintln!("JSON serialization failed: {e}");
-            println!(r#"{{"error":"parse","message":"JSON serialization failed"}}"#);
-        }
-    }
-}

src/cli/output/json.rs

@@ -37,38 +37,11 @@ impl CommandOutput {
     ///
     /// // Explicit columns (replaces from_json_cols):
     /// CommandOutput::builder().data(val).columns(&["price", "size"]).build()
-    ///
-    /// // Fixed message:
-    /// CommandOutput::builder().message("Done").build()
     /// ```
     pub(crate) fn builder() -> CommandOutputBuilder {
         CommandOutputBuilder::default()
     }
 
-    /// Create output from a JSON value with explicit table structure.
-    pub(crate) fn new(
-        data: serde_json::Value,
-        headers: Vec<String>,
-        rows: Vec<Vec<String>>,
-    ) -> Self {
-        Self {
-            data,
-            headers,
-            rows,
-        }
-    }
-
-    /// Create a simple key-value output (rendered as two-column table).
-    pub(crate) fn key_value(pairs: Vec<(String, String)>, json_data: serde_json::Value) -> Self {
-        let headers = vec!["Field".to_string(), "Value".to_string()];
-        let rows: Vec<Vec<String>> = pairs.into_iter().map(|(k, v)| vec![k, v]).collect();
-        Self {
-            data: json_data,
-            headers,
-            rows,
-        }
-    }
-
     /// Create output from a raw JSON value, auto-populating table rows from the data.
     ///
     /// - If the value is an array of objects, headers come from the first object's keys.
@@ -196,11 +169,10 @@ impl CommandOutput {
 pub(crate) struct CommandOutputBuilder {
     data: Option<serde_json::Value>,
     columns: Option<Vec<String>>,
-    message: Option<String>,
 }
 
 impl CommandOutputBuilder {
-    /// Set the JSON payload. Required unless `.message()` is used.
+    /// Set the JSON payload.
     pub(crate) fn data(mut self, data: serde_json::Value) -> Self {
         self.data = Some(data);
         self
@@ -212,17 +184,8 @@ impl CommandOutputBuilder {
         self
     }
 
-    /// Produce a single-message output (sets data to `{"message": msg}`).
-    pub(crate) fn message(mut self, msg: impl Into<String>) -> Self {
-        self.message = Some(msg.into());
-        self
-    }
-
     /// Consume the builder and produce a `CommandOutput`.
     pub(crate) fn build(self) -> CommandOutput {
-        if let Some(msg) = self.message {
-            return CommandOutput::message(&msg);
-        }
         match (self.data, self.columns) {
             (Some(data), Some(cols)) => {
                 let col_refs: Vec<&str> = cols.iter().map(|s| s.as_str()).collect();

src/cli/output/mod.rs

@@ -22,9 +22,3 @@ pub(crate) fn render(output: &CommandOutput) {
 
     println!("{table}");
 }
-
-/// Render a single append-only line for WebSocket streaming in table mode.
-pub(crate) fn render_stream_line(fields: &[(&str, &str)]) {
-    let parts: Vec<String> = fields.iter().map(|(k, v)| format!("{k}: {v}")).collect();
-    println!("{}", parts.join("  |  "));
-}

src/cli/output/table.rs

@@ -120,26 +120,26 @@ pub(crate) async fn run(ctx: &AppContext) -> Result<()> {
 struct BitmexPrompt;
 
 impl Prompt for BitmexPrompt {
-    fn render_prompt_left(&self) -> Cow<str> {
+    fn render_prompt_left(&self) -> Cow<'_, str> {
         "bitmex> ".into()
     }
 
-    fn render_prompt_right(&self) -> Cow<str> {
+    fn render_prompt_right(&self) -> Cow<'_, str> {
         "".into()
     }
 
-    fn render_prompt_indicator(&self, _mode: PromptEditMode) -> Cow<str> {
+    fn render_prompt_indicator(&self, _mode: PromptEditMode) -> Cow<'_, str> {
         "".into()
     }
 
-    fn render_prompt_multiline_indicator(&self) -> Cow<str> {
+    fn render_prompt_multiline_indicator(&self) -> Cow<'_, str> {
         "... ".into()
     }
 
     fn render_prompt_history_search_indicator(
         &self,
         _history_search: PromptHistorySearch,
-    ) -> Cow<str> {
+    ) -> Cow<'_, str> {
         "(history-search) ".into()
     }
 }
@@ -184,7 +184,7 @@ struct BitmexHighlighter;
 
 impl Highlighter for BitmexHighlighter {
     fn highlight(&self, line: &str, _cursor: usize) -> StyledText {
-        use nu_ansi_term::{Color, Style};
+        use nu_ansi_term::Style;
 
         let mut styled = StyledText::new();
         if line.is_empty() {

src/cli/shell.rs

@@ -191,7 +191,7 @@ pub(crate) fn save(cfg: &BitmexConfig) -> Result<()> {
 // Auto-migration
 // ---------------------------------------------------------------------------
 
-fn maybe_migrate_legacy_auth(cfg: &mut BitmexConfig, path: &Path) -> Result<()> {
+fn maybe_migrate_legacy_auth(cfg: &mut BitmexConfig, _path: &Path) -> Result<()> {
     let (Some(key), Some(secret)) = (
         cfg.auth.api_key.take(),
         cfg.auth.api_secret.take(),

src/config/mod.rs

@@ -53,8 +53,6 @@ pub trait ExchangeClient: Send + Sync {
         body: Option<&Value>,
         creds: &Credentials,
     ) -> impl Future<Output = Result<Value>> + Send;
-    fn base_url(&self) -> &str;
-    fn is_testnet(&self) -> bool;
 }
 
 use std::future::Future;
@@ -63,7 +61,6 @@ use std::future::Future;
 pub struct BitmexClient {
     http: reqwest::Client,
     pub(crate) base_url: String,
-    pub(crate) testnet: bool,
     verbose: bool,
     /// When Some, timing phases are collected and printed for every request.
     timing: Option<super::timing::TimingHandle>,
@@ -114,19 +111,17 @@ impl BitmexClient {
         Ok(Self {
             http: build_http_client(timing_handle.as_ref())?,
             base_url,
-            testnet,
             verbose,
             timing: timing_handle,
         })
     }
 
     /// Create a new client with an explicit base URL override.
-    pub fn new_with_url(base_url: String, testnet: bool, verbose: bool, timing: bool) -> Result<Self> {
+    pub fn new_with_url(base_url: String, verbose: bool, timing: bool) -> Result<Self> {
         let timing_handle = timing.then(super::timing::new_handle);
         Ok(Self {
             http: build_http_client(timing_handle.as_ref())?,
             base_url,
-            testnet,
             verbose,
             timing: timing_handle,
         })
@@ -202,25 +197,6 @@ impl BitmexClient {
         self.parse_response(resp, "PUT", &url).await
     }
 
-    /// Authenticated PATCH with JSON body.
-    pub async fn patch(&self, path: &str, body: &Value, creds: &Credentials) -> Result<Value> {
-        let full_path = format!("/api/v1{path}");
-        let body_str = serde_json::to_string(body)?;
-        let url = self.url(path, "");
-        if self.verbose { crate::cli::output::verbose(&format!("PATCH {url}")); }
-        self.begin_request();
-        let resp = super::middleware::execute_with_retry(self.verbose, || async {
-            let expires = auth::generate_expires()?;
-            let sig = auth::sign("PATCH", &full_path, expires, &body_str, &creds.api_secret)?;
-            let headers = self.auth_headers(&creds.api_key, expires, &sig)?;
-            self.http.patch(&url).headers(headers)
-                .header("Content-Type", "application/json")
-                .body(body_str.clone()).send().await
-                .map_err(|e| BitmexError::Network { message: e.to_string() })
-        }).await?;
-        self.parse_response(resp, "PATCH", &url).await
-    }
-
     /// Authenticated DELETE, optional JSON body.
     pub async fn delete(
         &self,
@@ -413,14 +389,6 @@ impl ExchangeClient for BitmexClient {
     ) -> Result<Value> {
         BitmexClient::delete(self, path, query, body, creds).await
     }
-
-    fn base_url(&self) -> &str {
-        &self.base_url
-    }
-
-    fn is_testnet(&self) -> bool {
-        self.testnet
-    }
 }
 
 /// Extract a human-readable error message from a BitMEX error response body.

src/exchange/client.rs

@@ -241,7 +241,7 @@ pub enum Command {
 
 fn build_client(ctx: &AppContext) -> Result<BitmexClient> {
     if let Some(ref url) = ctx.api_url {
-        BitmexClient::new_with_url(url.clone(), ctx.testnet, ctx.verbose, ctx.timing)
+        BitmexClient::new_with_url(url.clone(), ctx.verbose, ctx.timing)
     } else {
         BitmexClient::new(ctx.testnet, ctx.verbose, ctx.timing)
     }