@plures/pluresdb 1.6.10 → 2.9.6

package/examples/tauri-demo/README.md

@@ -1,240 +0,0 @@
-# PluresDB Tauri Demo
-
-A complete example of integrating PluresDB into a Tauri application for local-first desktop database access.
-
-## Features
-
-- 🚀 **Native Performance**: Direct Rust-to-Rust integration
-- 💾 **Local-First**: All data stored locally with no network dependency
-- 🔒 **Secure**: No exposed ports, OS-level security
-- ⚡ **Fast**: ~0.05ms latency, 200k+ ops/s throughput
-
-## Project Structure
-
-```
-tauri-demo/
-├── src-tauri/           # Rust backend
-│   ├── src/
-│   │   └── main.rs      # Tauri app with PluresDB commands
-│   ├── Cargo.toml       # Rust dependencies
-│   └── tauri.conf.json  # Tauri configuration
-├── src/                 # Frontend (HTML/JS/TS)
-│   ├── index.html
-│   └── main.js
-└── README.md
-```
-
-## Quick Start
-
-### Prerequisites
-
-- Rust and Cargo installed
-- Node.js and npm (for frontend tooling)
-- Tauri CLI: `cargo install tauri-cli`
-
-### Installation
-
-1. Navigate to this directory:
-```bash
-cd examples/tauri-demo
-```
-
-2. Install dependencies:
-```bash
-npm install
-```
-
-3. Run the app:
-```bash
-cargo tauri dev
-```
-
-## Implementation Guide
-
-### 1. Add PluresDB to Cargo.toml
-
-```toml
-[dependencies]
-pluresdb-core = "1.6"
-tauri = { version = "1.5", features = ["api-all"] }
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-parking_lot = "0.12"
-```
-
-### 2. Create Tauri Commands (src-tauri/src/main.rs)
-
-```rust
-use pluresdb_core::{CrdtStore, CrdtNode};
-use parking_lot::Mutex;
-use std::sync::Arc;
-use tauri::State;
-
-struct AppState {
-    db: Arc<Mutex<CrdtStore>>,
-}
-
-#[tauri::command]
-async fn pluresdb_put(
-    state: State<'_, AppState>,
-    id: String,
-    data: serde_json::Value,
-) -> Result<String, String> {
-    let mut db = state.db.lock();
-    let node_id = db.put(id, "tauri".to_string(), data);
-    Ok(node_id)
-}
-
-#[tauri::command]
-async fn pluresdb_get(
-    state: State<'_, AppState>,
-    id: String,
-) -> Result<Option<serde_json::Value>, String> {
-    let db = state.db.lock();
-    match db.get(id) {
-        Some(record) => Ok(Some(record.data)),
-        None => Ok(None),
-    }
-}
-
-#[tauri::command]
-async fn pluresdb_delete(
-    state: State<'_, AppState>,
-    id: String,
-) -> Result<(), String> {
-    let mut db = state.db.lock();
-    db.delete(&id).map_err(|e| e.to_string())
-}
-
-#[tauri::command]
-async fn pluresdb_list(
-    state: State<'_, AppState>,
-) -> Result<Vec<serde_json::Value>, String> {
-    let db = state.db.lock();
-    let records = db.list();
-    let items: Vec<serde_json::Value> = records
-        .into_iter()
-        .map(|r| serde_json::json!({ "id": r.id, "data": r.data }))
-        .collect();
-    Ok(items)
-}
-
-fn main() {
-    // Initialize database
-    let db = Arc::new(Mutex::new(CrdtStore::default()));
-
-    tauri::Builder::default()
-        .manage(AppState { db })
-        .invoke_handler(tauri::generate_handler![
-            pluresdb_put,
-            pluresdb_get,
-            pluresdb_delete,
-            pluresdb_list,
-        ])
-        .run(tauri::generate_context!())
-        .expect("error while running tauri application");
-}
-```
-
-### 3. Frontend Integration (src/main.js)
-
-```javascript
-const { invoke } = window.__TAURI__.tauri;
-
-class PluresDBTauri {
-  async put(id, data) {
-    return await invoke("pluresdb_put", { id, data });
-  }
-  
-  async get(id) {
-    return await invoke("pluresdb_get", { id });
-  }
-  
-  async delete(id) {
-    await invoke("pluresdb_delete", { id });
-  }
-  
-  async list() {
-    return await invoke("pluresdb_list");
-  }
-}
-
-// Usage
-const db = new PluresDBTauri();
-
-async function demo() {
-  // Insert data
-  await db.put("user:1", {
-    name: "Alice",
-    email: "alice@example.com"
-  });
-  
-  // Retrieve data
-  const user = await db.get("user:1");
-  console.log("User:", user);
-  
-  // List all
-  const all = await db.list();
-  console.log("All records:", all.length);
-}
-
-demo();
-```
-
-## Building for Production
-
-### Development Build
-```bash
-cargo tauri dev
-```
-
-### Production Build
-```bash
-cargo tauri build
-```
-
-This creates:
-- **macOS**: `.app` bundle and `.dmg` installer
-- **Windows**: `.exe` installer and `.msi` package
-- **Linux**: `.AppImage` and `.deb` package
-
-## Performance Benchmarks
-
-| Operation | Latency | Throughput |
-|-----------|---------|------------|
-| PUT       | ~0.05ms | ~200k ops/s |
-| GET       | ~0.03ms | ~300k ops/s |
-| DELETE    | ~0.04ms | ~250k ops/s |
-| LIST      | ~1ms    | ~20k ops/s |
-
-**vs. HTTP REST API**:
-- 100x lower latency
-- 200x higher throughput
-- No network overhead
-- No security risks from exposed ports
-
-## Features Demonstrated
-
-- ✅ Basic CRUD operations (put, get, delete, list)
-- ✅ Real-time updates (CRDT-based)
-- ✅ Persistent storage (file-based)
-- ✅ TypeScript support (type definitions)
-- ✅ Error handling
-- ✅ Cross-platform builds
-
-## Next Steps
-
-1. Add vector search: `pluresdb_vector_search` command
-2. Add P2P sync: Connect to remote peers
-3. Add encryption: E2E encrypted data sharing
-4. Add authentication: User management
-
-## Resources
-
-- [Tauri Documentation](https://tauri.app/v1/guides/)
-- [PluresDB Documentation](../../docs/)
-- [Local-First Integration Guide](../../docs/LOCAL_FIRST_INTEGRATION.md)
-
-## License
-
-This example is part of PluresDB and is licensed under AGPL-3.0.

package/examples/tauri-integration.md

@@ -1,260 +0,0 @@
-# Tauri Integration Example
-
-This example demonstrates how to integrate PluresDB directly into a Tauri application without any network overhead.
-
-## Architecture
-
-```
-┌─────────────────────────────────────┐
-│   Tauri Frontend (HTML/JS/TS)      │
-│                                     │
-│   PluresDBLocalFirst (auto-detect)  │
-└──────────────┬──────────────────────┘
-               │ Tauri IPC
-               │ (in-process, no network)
-┌──────────────▼──────────────────────┐
-│   Tauri Backend (Rust)              │
-│                                     │
-│   pluresdb-core                     │
-│   pluresdb-storage                  │
-│   pluresdb-sync                     │
-└─────────────────────────────────────┘
-```
-
-## Setup
-
-### 1. Create Tauri App
-
-```bash
-npm create tauri-app@latest my-pluresdb-app
-cd my-pluresdb-app
-```
-
-### 2. Add PluresDB Dependencies
-
-Add to `src-tauri/Cargo.toml`:
-
-```toml
-[dependencies]
-pluresdb-core = "0.1"
-pluresdb-storage = "0.1"
-pluresdb-sync = "0.1"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-tauri = { version = "1.5", features = ["shell-open"] }
-parking_lot = "0.12"
-```
-
-### 3. Implement Tauri Commands
-
-Edit `src-tauri/src/main.rs`:
-
-```rust
-// Prevents additional console window on Windows in release
-#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
-
-use pluresdb_core::{Database, DatabaseOptions, CrdtStore};
-use serde_json::Value;
-use std::sync::Arc;
-use parking_lot::Mutex;
-use tauri::State;
-
-// Application state holding the database instance
-struct AppState {
-    db: Arc<Mutex<CrdtStore>>,
-}
-
-#[tauri::command]
-async fn pluresdb_put(
-    state: State<'_, AppState>,
-    id: String,
-    data: Value,
-) -> Result<String, String> {
-    let db = state.db.lock();
-    let node_id = db.put(id.clone(), "tauri-app".to_string(), data);
-    Ok(node_id)
-}
-
-#[tauri::command]
-async fn pluresdb_get(
-    state: State<'_, AppState>,
-    id: String,
-) -> Result<Option<Value>, String> {
-    let db = state.db.lock();
-    match db.get(id) {
-        Some(record) => Ok(Some(record.data)),
-        None => Ok(None),
-    }
-}
-
-#[tauri::command]
-async fn pluresdb_delete(
-    state: State<'_, AppState>,
-    id: String,
-) -> Result<(), String> {
-    let db = state.db.lock();
-    db.delete(&id).map_err(|e| e.to_string())
-}
-
-#[tauri::command]
-async fn pluresdb_list(
-    state: State<'_, AppState>,
-) -> Result<Vec<Value>, String> {
-    let db = state.db.lock();
-    let records = db.list();
-    
-    let result = records
-        .into_iter()
-        .map(|record| {
-            serde_json::json!({
-                "id": record.id,
-                "data": record.data,
-                "timestamp": record.timestamp.to_rfc3339(),
-            })
-        })
-        .collect();
-    
-    Ok(result)
-}
-
-#[tauri::command]
-async fn pluresdb_vector_search(
-    state: State<'_, AppState>,
-    query: String,
-    limit: usize,
-) -> Result<Vec<Value>, String> {
-    // Vector search implementation will be added in future update
-    // For now, return empty results
-    Ok(vec![])
-}
-
-fn main() {
-    // Initialize database
-    let db = CrdtStore::default();
-    
-    tauri::Builder::default()
-        .manage(AppState {
-            db: Arc::new(Mutex::new(db)),
-        })
-        .invoke_handler(tauri::generate_handler![
-            pluresdb_put,
-            pluresdb_get,
-            pluresdb_delete,
-            pluresdb_list,
-            pluresdb_vector_search,
-        ])
-        .run(tauri::generate_context!())
-        .expect("error while running tauri application");
-}
-```
-
-### 4. Use in Frontend
-
-Install PluresDB in your frontend:
-
-```bash
-npm install @plures/pluresdb
-```
-
-Then use it in your frontend code (e.g., `src/App.tsx` or `src/main.js`):
-
-```typescript
-import { PluresDBLocalFirst } from "@plures/pluresdb/local-first";
-
-// Auto-detects Tauri environment and uses native integration
-const db = new PluresDBLocalFirst({ mode: "auto" });
-
-async function main() {
-  // Insert data
-  await db.put("user:1", {
-    name: "Alice",
-    email: "alice@example.com",
-    role: "admin",
-  });
-
-  // Retrieve data
-  const user = await db.get("user:1");
-  console.log("User:", user);
-
-  // List all nodes
-  const allNodes = await db.list();
-  console.log("Total nodes:", allNodes.length);
-
-  // Delete data
-  await db.delete("user:1");
-}
-
-main().catch(console.error);
-```
-
-## Performance Benefits
-
-Compared to network-based integration:
-
-| Metric | Network Mode | Tauri Mode | Improvement |
-|--------|--------------|------------|-------------|
-| **Latency** | ~5-10ms | ~0.05ms | **100-200x faster** |
-| **Throughput** | ~1k ops/s | ~200k ops/s | **200x faster** |
-| **Memory** | 2 processes | 1 process | **50% reduction** |
-| **Security** | Exposed port | No network | **No attack surface** |
-
-## Features
-
-✅ **Zero Network Overhead**: Direct in-process communication  
-✅ **Native Performance**: Rust speed with JavaScript convenience  
-✅ **Type Safety**: Full TypeScript support  
-✅ **Offline-First**: No server required  
-✅ **Persistent Storage**: Data saved to filesystem  
-✅ **Cross-Platform**: Works on Windows, macOS, Linux  
-
-## Advanced: With Persistent Storage
-
-To enable file-based persistence:
-
-```rust
-// In main.rs
-use pluresdb_core::DatabaseOptions;
-
-fn main() {
-    // Use file-based storage instead of in-memory
-    let options = DatabaseOptions::with_file("./data/plures.db")
-        .create_if_missing(true);
-    
-    let db = Database::open(options)
-        .expect("Failed to open database");
-    
-    tauri::Builder::default()
-        .manage(AppState {
-            db: Arc::new(Mutex::new(db)),
-        })
-        // ... rest of setup
-}
-```
-
-## Next Steps
-
-- See [LOCAL_FIRST_INTEGRATION.md](../../docs/LOCAL_FIRST_INTEGRATION.md) for full architecture
-- Check out the [Browser WASM example](./browser-wasm-integration.md) for web apps
-- Explore [IPC integration](./native-ipc-integration.md) for desktop apps
-
-## Troubleshooting
-
-### "Tauri backend requires Tauri environment" error
-
-Make sure you're running the app in Tauri:
-
-```bash
-npm run tauri dev
-```
-
-Not in a regular browser or Node.js environment.
-
-### Build errors with Rust dependencies
-
-Ensure you have the Rust toolchain installed:
-
-```bash
-curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-```
-
-On Windows, you may need to install Visual Studio Build Tools.

package/examples/vscode-extension-example/README.md

@@ -1,95 +0,0 @@
-# PluresDB VSCode Extension Example
-
-This is an example VSCode extension that demonstrates how to integrate PluresDB into your VSCode extension.
-
-## Features
-
-- **Store Data**: Store key-value pairs in PluresDB
-- **Retrieve Data**: Retrieve data by key
-- **Vector Search**: Perform semantic search across your data
-- **SQLite Compatibility**: Use familiar SQLite API
-
-## Installation
-
-1. Install dependencies:
-
-   ```bash
-   npm install
-   ```
-
-2. Compile the extension:
-
-   ```bash
-   npm run compile
-   ```
-
-3. Press F5 to run the extension in a new Extension Development Host window
-
-## Usage
-
-1. Open the Command Palette (Ctrl+Shift+P)
-2. Run one of these commands:
-   - `PluresDB Example: Hello World` - Shows a hello world message
-   - `PluresDB Example: Store Data` - Store data in PluresDB
-   - `PluresDB Example: Retrieve Data` - Retrieve data from PluresDB
-   - `PluresDB Example: Search Data` - Search data with vector search
-
-## Code Example
-
-```typescript
-import { SQLiteCompatibleAPI } from "pluresdb";
-
-// Initialize database
-const db = new SQLiteCompatibleAPI({
-  config: {
-    dataDir: path.join(context.globalStorageUri.fsPath, "pluresdb"),
-    port: 34567,
-    host: "localhost",
-  },
-});
-
-// Start database
-await db.start();
-
-// Store data
-await db.put("user:123", { name: "John", email: "john@example.com" });
-
-// Retrieve data
-const user = await db.getValue("user:123");
-
-// Vector search
-const results = await db.vectorSearch("machine learning", 10);
-
-// SQL queries
-await db.exec("CREATE TABLE users (id TEXT, name TEXT)");
-const users = await db.all("SELECT * FROM users");
-```
-
-## Migration from SQLite
-
-If you're migrating from SQLite, the API is nearly identical:
-
-```typescript
-// Before (SQLite)
-import sqlite3 from "sqlite3";
-const db = new sqlite3.Database("./data.db");
-
-// After (PluresDB)
-import { SQLiteCompatibleAPI } from "pluresdb";
-const db = new SQLiteCompatibleAPI();
-await db.start();
-```
-
-## Benefits of PluresDB
-
-- **P2P Sync**: Share data across devices
-- **Offline-First**: Work without internet
-- **Vector Search**: Semantic search capabilities
-- **Encrypted Sharing**: Secure data sharing
-- **SQLite Compatibility**: Easy migration
-
-## Learn More
-
-- [PluresDB Documentation](../../README.md)
-- [VSCode Extension API](https://code.visualstudio.com/api)
-- [Migration Guide](../../docs/VSCODE_MIGRATION.md)

package/examples/vscode-extension-example/package.json

@@ -1,49 +0,0 @@
-{
-  "name": "pluresdb-extension-example",
-  "displayName": "PluresDB Extension Example",
-  "description": "Example VSCode extension using PluresDB",
-  "version": "0.0.1",
-  "engines": {
-    "vscode": "^1.74.0"
-  },
-  "categories": [
-    "Other"
-  ],
-  "activationEvents": [
-    "onCommand:pluresdb-example.helloWorld"
-  ],
-  "main": "./out/extension.js",
-  "contributes": {
-    "commands": [
-      {
-        "command": "pluresdb-example.helloWorld",
-        "title": "Hello World from PluresDB"
-      },
-      {
-        "command": "pluresdb-example.storeData",
-        "title": "Store Data in PluresDB"
-      },
-      {
-        "command": "pluresdb-example.retrieveData",
-        "title": "Retrieve Data from PluresDB"
-      },
-      {
-        "command": "pluresdb-example.searchData",
-        "title": "Search Data with Vector Search"
-      }
-    ]
-  },
-  "scripts": {
-    "vscode:prepublish": "npm run compile",
-    "compile": "tsc -p ./",
-    "watch": "tsc -watch -p ./"
-  },
-  "devDependencies": {
-    "@types/vscode": "^1.74.0",
-    "@types/node": "16.x",
-    "typescript": "^4.9.4"
-  },
-  "dependencies": {
-    "pluresdb": "file:../.."
-  }
-}