rust-fetch 0.7.2 → 1.0.0

package/README.md

@@ -0,0 +1,192 @@
+# Rust Fetch - World-Class HTTP Client for WebAssembly
+
+[![License: MIT/Apache-2.0](https://img.shields.io/badge/License-MIT%2FApache--2.0-blue.svg)](LICENSE)
+[![Rust](https://img.shields.io/badge/rust-%23000000.svg?style=flat&logo=rust&logoColor=white)](https://www.rust-lang.org/)
+[![WebAssembly](https://img.shields.io/badge/WebAssembly-654FF0?style=flat&logo=WebAssembly&logoColor=white)](https://webassembly.org/)
+
+A production-ready, world-class HTTP client library for WebAssembly with excellent error handling, retry logic, and a clean API design.
+
+## 🚀 Features
+
+- **Type-safe HTTP Client**: Builder pattern for constructing requests with compile-time safety
+- **Comprehensive Error Handling**: Detailed error types with context and proper error chaining
+- **Automatic Retries**: Built-in retry logic with exponential backoff for transient failures
+- **Multiple Response Formats**: Support for JSON, text, and binary responses
+- **Platform Optimized**: Specific optimizations for both WASM and native targets
+- **Developer Friendly**: Clean API with both simple functions and advanced client builders
+- **Backward Compatible**: Maintains compatibility with legacy API while providing modern alternatives
+
+## 📦 Installation
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+rust-fetch = "1.0.0"
+```
+
+For WebAssembly projects, make sure to include:
+
+```toml
+[dependencies]
+wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+```
+
+## 🔧 Usage
+
+### Simple API
+
+For quick and easy HTTP requests:
+
+```rust
+use rust_fetch::prelude::*;
+
+// Fetch JSON data
+let data = fetch_json("https://api.example.com/data").await?;
+
+// Fetch text/HTML
+let html = fetch_text("https://example.com").await?;
+
+// Advanced request with options
+let response = fetch_with_options(
+    "https://api.example.com/users",
+    "POST",
+    headers_obj, // JavaScript headers object
+    Some(r#"{"name": "John Doe"}"#.to_string()),
+).await?;
+```
+
+### Advanced Client API
+
+For more control and configuration:
+
+```rust
+use rust_fetch::client::Client;
+use rust_fetch::types::RetryConfig;
+use std::time::Duration;
+
+// Create a configured client
+let client = Client::builder()
+    .base_url("https://api.example.com")
+    .default_header("Authorization", "Bearer token")
+    .timeout(Duration::from_secs(10))
+    .retry_config(RetryConfig {
+        max_retries: 3,
+        initial_delay: Duration::from_millis(100),
+        ..Default::default()
+    })
+    .build()?;
+
+// Make requests
+let response = client
+    .post("/users")
+    .json(&serde_json::json!({
+        "name": "Jane Doe",
+        "email": "jane@example.com"
+    }))?
+    .send()
+    .await?;
+
+// Access response data
+println!("Status: {}", response.status);
+if let Some(json) = response.json() {
+    println!("Response: {:?}", json);
+}
+```
+
+### WebAssembly JavaScript API
+
+When compiled to WebAssembly, the library exposes a JavaScript-friendly API:
+
+```javascript
+import init, { WasmClient, fetch_json, fetch_text } from './rust_fetch.js';
+
+await init();
+
+// Simple API
+const data = await fetch_json("https://api.example.com/data");
+const html = await fetch_text("https://example.com");
+
+// Client API
+const client = new WasmClient();
+const response = await client.get("https://api.example.com/users");
+console.log(response);
+```
+
+## 🏗️ Architecture
+
+The library is organized into several modules:
+
+- **`error`**: Comprehensive error types with detailed context
+- **`types`**: Core types like `Method`, `Headers`, `Response`, etc.
+- **`client`**: The main HTTP client with builder pattern
+- **`http`**: High-level convenience functions for common use cases
+
+### Error Handling
+
+The library provides rich error types that preserve context:
+
+```rust
+use rust_fetch::error::{Error, Result};
+
+match fetch_json(url).await {
+    Ok(data) => println!("Success: {:?}", data),
+    Err(Error::Network { message, source }) => {
+        eprintln!("Network error: {}", message);
+    }
+    Err(Error::Http { status, status_text, body }) => {
+        eprintln!("HTTP {}: {}", status, status_text);
+    }
+    Err(e) => eprintln!("Other error: {}", e),
+}
+```
+
+### Request Building
+
+The client provides a fluent API for building requests:
+
+```rust
+let response = client
+    .request(Method::Put, "/users/123")
+    .header("Content-Type", "application/json")
+    .header("X-Custom-Header", "value")
+    .timeout(Duration::from_secs(5))
+    .json(&updated_user)?
+    .send()
+    .await?;
+```
+
+## 🧪 Testing
+
+Run tests for native target:
+
+```bash
+cargo test
+```
+
+Run tests for WebAssembly target:
+
+```bash
+wasm-pack test --headless --chrome
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📄 License
+
+This project is licensed under either of
+
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+## 🙏 Acknowledgments
+
+Built with love using:
+- [reqwest](https://github.com/seanmonstar/reqwest) - HTTP client
+- [wasm-bindgen](https://github.com/rustwasm/wasm-bindgen) - WebAssembly bindings
+- [serde](https://github.com/serde-rs/serde) - Serialization framework

package/package.json

@@ -1,30 +1,31 @@
 {
   "name": "rust-fetch",
-  "version": "0.7.2",
-  "publishConfig": {
-    "access": "public"
+  "type": "module",
+  "collaborators": [
+    "Asem Qaffaf <asem@qaffaf.com>"
+  ],
+  "description": "A world-class WebAssembly HTTP client library with excellent error handling and clean API",
+  "version": "1.0.0",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/asemqaffaf/rust-fetch"
   },
-  "export": {
-    "fetch": "./wasm-module/pkg/wasm_module",
-    "server": "server.ts",
-    "client": "client.ts"
-  },
-  "scripts": {
-    "build": "cd wasm-module && tsc",
-    "build:wasm": "cd wasm-module && rm -rf pkg && wasm-pack build --target web && cd pkg && rm -rf .gitignore",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "path": "^0.12.7",
-    "wasm-module": "file:wasm-module/pkg"
-  },
-  "devDependencies": {
-    "@types/node": "^22.13.5",
-    "typescript": "^5.7.3"
-  },
-  "main": "index.js",
-  "description": ""
-}
+  "files": [
+    "rust_fetch_bg.wasm",
+    "rust_fetch.js",
+    "rust_fetch.d.ts"
+  ],
+  "main": "rust_fetch.js",
+  "types": "rust_fetch.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ],
+  "keywords": [
+    "wasm",
+    "http",
+    "client",
+    "fetch",
+    "webassembly"
+  ]
+}

package/rust_fetch.d.ts

@@ -0,0 +1,106 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Simple fetch function for JSON data
+ */
+export function fetch_json(url: string): Promise<any>;
+/**
+ * Fetch JSON data and return as a Promise
+ */
+export function fetch_json_promise(url: string): Promise<any>;
+/**
+ * Simple fetch function for text/HTML data
+ */
+export function fetch_text(url: string): Promise<string>;
+/**
+ * Advanced fetch function with full options
+ */
+export function fetch_with_options(url: string, method: string, headers: any, body?: string): Promise<any>;
+/**
+ * Create a configured HTTP client (exported for advanced use)
+ */
+export function create_client(): WasmClient;
+/**
+ * Fetch JSON data (deprecated, use fetch_json instead)
+ */
+export function fetch_wasm_json(url: string): Promise<any>;
+/**
+ * Fetch HTML data (deprecated, use fetch_text instead)
+ */
+export function fetch_wasm_html(url: string): Promise<string>;
+/**
+ * Fetch data and return as map (deprecated, use fetch_json instead)
+ */
+export function fetch_wasm_map(url: string): Promise<any>;
+/**
+ * Fetch API data (deprecated, use fetch_json instead)
+ */
+export function fetch_wasm_api(url: string): Promise<any>;
+/**
+ * WASM bindings for the client
+ */
+export class WasmClient {
+  free(): void;
+  /**
+   * Create a new client
+   */
+  constructor();
+  /**
+   * Make a GET request
+   */
+  get(url: string): Promise<any>;
+  /**
+   * Make a POST request with JSON body
+   */
+  post_json(url: string, body: any): Promise<any>;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly fetch_json: (a: number, b: number) => any;
+  readonly fetch_json_promise: (a: number, b: number) => any;
+  readonly fetch_text: (a: number, b: number) => any;
+  readonly fetch_with_options: (a: number, b: number, c: number, d: number, e: any, f: number, g: number) => any;
+  readonly create_client: () => [number, number, number];
+  readonly fetch_wasm_json: (a: number, b: number) => any;
+  readonly fetch_wasm_html: (a: number, b: number) => any;
+  readonly fetch_wasm_map: (a: number, b: number) => any;
+  readonly fetch_wasm_api: (a: number, b: number) => any;
+  readonly __wbg_wasmclient_free: (a: number, b: number) => void;
+  readonly wasmclient_new: () => [number, number, number];
+  readonly wasmclient_get: (a: number, b: number, c: number) => any;
+  readonly wasmclient_post_json: (a: number, b: number, c: number, d: any) => any;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_4: WebAssembly.Table;
+  readonly __wbindgen_export_5: WebAssembly.Table;
+  readonly __externref_table_dealloc: (a: number) => void;
+  readonly closure243_externref_shim: (a: number, b: number, c: any) => void;
+  readonly closure265_externref_shim: (a: number, b: number, c: any, d: any) => void;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;