rust-fetch 1.0.0 → 1.0.2

package/README.md

@@ -1,10 +1,10 @@
-# Rust Fetch - World-Class HTTP Client for WebAssembly
+# rust-fetch
 
-[![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/)
+[![npm version](https://img.shields.io/npm/v/rust-fetch.svg)](https://www.npmjs.com/package/rust-fetch)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](LICENSE)
 [![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.
+A high-performance, world-class HTTP client for JavaScript/TypeScript powered by WebAssembly. Built with Rust for blazing-fast, memory-safe HTTP operations in both browser and Node.js environments.
 
 ## 🚀 Features
 
@@ -18,19 +18,14 @@ A production-ready, world-class HTTP client library for WebAssembly with excelle
 
 ## 📦 Installation
 
-Add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-rust-fetch = "1.0.0"
+```bash
+npm install rust-fetch
 ```
 
-For WebAssembly projects, make sure to include:
+or
 
-```toml
-[dependencies]
-wasm-bindgen = "0.2"
-wasm-bindgen-futures = "0.4"
+```bash
+yarn add rust-fetch
 ```
 
 ## 🔧 Usage
@@ -39,79 +34,78 @@ wasm-bindgen-futures = "0.4"
 
 For quick and easy HTTP requests:
 
-```rust
-use rust_fetch::prelude::*;
+### WASM Client Example
+How to use the imported `WasmClient` to make HTTP requests from the browser or Node.js environment:
 
-// Fetch JSON data
-let data = fetch_json("https://api.example.com/data").await?;
+#### Simple GET Request
+Here's how to make a simple GET request using `WasmClient`:
 
-// 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?;
-```
+```javascript
+import init, { WasmClient } from 'rust-fetch/client';
 
-### Advanced Client API
+await init();
 
-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);
-}
+const client = new WasmClient();
+
+client.get('https://jsonplaceholder.typicode.com/posts/1')
+    .then(response => console.log(response))
+    .catch(error => console.error('Error:', error));
 ```
 
-### WebAssembly JavaScript API
+#### POST Request with JSON
+Here's how to make a POST request with a JSON body:
+
+```javascript
+const data = { title: 'foo', body: 'bar', userId: 1 };
+
+client.post_json('https://jsonplaceholder.typicode.com/posts', data)
+    .then(response => console.log(response))
+    .catch(error => console.error('Error:', error));
+```
 
-When compiled to WebAssembly, the library exposes a JavaScript-friendly API:
+### Using Fetch Functions
 
 ```javascript
-import init, { WasmClient, fetch_json, fetch_text } from './rust_fetch.js';
+import init, { fetch_json, fetch_text } from 'rust-fetch/client';
 
+// Initialize WASM module
 await init();
 
-// Simple API
-const data = await fetch_json("https://api.example.com/data");
-const html = await fetch_text("https://example.com");
+// Fetch JSON data
+try {
+  const data = await fetch_json('https://api.example.com/data');
+  console.log('JSON data:', data);
+} catch (error) {
+  console.error('Error fetching JSON:', error);
+}
+
+// Fetch text/HTML
+try {
+  const html = await fetch_text('https://example.com');
+  console.log('HTML content:', html);
+} catch (error) {
+  console.error('Error fetching HTML:', error);
+}
+```
 
-// Client API
-const client = new WasmClient();
-const response = await client.get("https://api.example.com/users");
-console.log(response);
+### Advanced Client API
+
+For more control and enhanced configurations, use the `fetch_with_options` to fine-tune HTTP requests:
+
+#### Using Advanced Options
+You can specify HTTP method, headers, and body:
+
+```javascript
+import { fetch_with_options } from 'rust-fetch/client';
+
+const url = 'https://jsonplaceholder.typicode.com/posts';
+const method = 'POST';
+const headers = { 'Content-Type': 'application/json' };
+const body = JSON.stringify({ userId: 1, title: 'foo', body: 'bar' });
+
+fetch_with_options(url, method, headers, body)
+    .then(response => console.log(response))
+    .catch(error => console.error('Error:', error));
 ```
 
 ## 🏗️ Architecture
@@ -127,66 +121,147 @@ The library is organized into several modules:
 
 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),
+```javascript
+try {
+  const data = await fetch_json(url);
+  console.log('Success:', data);
+} catch (error) {
+  // Error handling with detailed context
+  console.error('Failed to fetch:', error.message);
 }
 ```
 
-### Request Building
+## API Reference
+
+### HTTP Functions
+
+#### `fetch_json(url: string): Promise<any>`
+Fetches JSON data from the specified URL and returns it as a JavaScript object.
+
+```javascript
+import { fetch_json } from 'rust-fetch/client';
+
+const data = await fetch_json('https://jsonplaceholder.typicode.com/todos/1');
+```
+
+#### `fetch_text(url: string): Promise<string>`
+Fetches text/HTML content from the specified URL and returns it as a string.
 
-The client provides a fluent API for building requests:
+```javascript
+import { fetch_text } from 'rust-fetch/client';
 
-```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?;
+const html = await fetch_text('https://example.com');
 ```
 
-## 🧪 Testing
+#### `fetch_with_options(url: string, method: string, headers: object, body?: string): Promise<object>`
+Advanced fetch function with full control over the request.
 
-Run tests for native target:
+```javascript
+import { fetch_with_options } from 'rust-fetch/client';
+
+const response = await fetch_with_options(
+    'https://api.example.com/users',
+    'POST',
+    { 'Content-Type': 'application/json' },
+    JSON.stringify({ name: 'John Doe' })
+);
+```
 
-```bash
-cargo test
+### WasmClient Class
+
+#### `new WasmClient()`
+Creates a new HTTP client instance.
+
+```javascript
+const client = new WasmClient();
 ```
 
-Run tests for WebAssembly target:
+#### `client.get(url: string): Promise<object>`
+Performs a GET request.
 
-```bash
-wasm-pack test --headless --chrome
+```javascript
+const response = await client.get('https://api.example.com/data');
+```
+
+#### `client.post_json(url: string, body: object): Promise<object>`
+Performs a POST request with JSON body.
+
+```javascript
+const response = await client.post_json('https://api.example.com/users', {
+    name: 'Jane Doe',
+    email: 'jane@example.com'
+});
 ```
 
-## 🤝 Contributing
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+## Performance Considerations
+
+- The WASM module adds a small overhead for initialization (~100-200ms on first load)
+- Once loaded, HTTP operations benefit from Rust's efficient memory management
+- Best suited for applications that make multiple HTTP requests or need predictable performance
+
+## Browser Support
+
+- Chrome 57+
+- Firefox 52+
+- Safari 11+
+- Edge 16+
+- Node.js 14+
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the ISC License - see the LICENSE file for details.
+
+## Troubleshooting
+
+### WASM Module Not Loading
+
+If you encounter issues with the WASM module not loading:
+
+1. Ensure your server supports the `application/wasm` MIME type
+2. Check that the WASM file is being served correctly
+3. Verify you're awaiting the `initWasm()` call before using any functions
+
+### CORS Issues
+
+When fetching from external APIs, ensure:
+
+1. The target server allows CORS requests
+2. You're using HTTPS URLs in production
+3. Consider using a proxy server for APIs that don't support CORS
+
+### Node.js Path Issues
 
-## 📄 License
+If you encounter path resolution issues in Node.js:
 
-This project is licensed under either of
+1. Ensure the package is installed correctly
+2. Check that the WASM file exists in `node_modules/rust-fetch/wasm-module/pkg/`
+3. Try reinstalling the package
 
-- 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)
+## Acknowledgments
 
-at your option.
+- Built with [wasm-bindgen](https://github.com/rustwasm/wasm-bindgen)
+- Uses [reqwest](https://github.com/seanmonstar/reqwest) for HTTP operations
+- Inspired by the Rust and WebAssembly community
 
-## 🙏 Acknowledgments
+## Roadmap
 
-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
+- [ ] Add support for POST, PUT, DELETE methods
+- [ ] Implement request headers customization
+- [ ] Add streaming support for large responses
+- [ ] Implement request cancellation
+- [ ] Add comprehensive test suite
+- [ ] Performance benchmarks against native fetch
+- [ ] Support for form data and file uploads
+- [ ] WebSocket support
+- [ ] Request/response interceptors

package/package.json

@@ -5,7 +5,7 @@
     "Asem Qaffaf <asem@qaffaf.com>"
   ],
   "description": "A world-class WebAssembly HTTP client library with excellent error handling and clean API",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",
@@ -28,4 +28,4 @@
     "fetch",
     "webassembly"
   ]
-}
+}