Merge pull request 'dev' (#6) from dev into main

Reviewed-on: #6

.dockerignore

@@ -0,0 +1,5 @@
+target/
+**/*.rs.bk
+node_modules/
+Dockerfile
+docker-compose.yml

.gitignore

@@ -15,4 +15,8 @@ playwright/.cache/
 # Sass cache dir
 .sass-cache/
 
-.idea/
+.idea/
+
+# Ignore database file
+compareware.db
+.qodo

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "compareware"
-version = "0.1.0"
+version = "0.1.3"
 edition = "2021"
 
 [lib]
@@ -15,20 +15,27 @@ leptos = { version = "0.6" }
 leptos_meta = { version = "0.6" }
 leptos_actix = { version = "0.6", optional = true }
 leptos_router = { version = "0.6" }
+paste = "1.0"
 wasm-bindgen = "=0.2.99"
+rusqlite = { version = "0.27.0", optional = true}
 serde = { version = "1.0", features = ["derive"] }
-uuid = { version = "1.0", features = ["v4"] }
+uuid = { version = "1.0", features = ["v4", "js"] }
 web-sys = { version = "0.3", features = ["Event"] }
 nostr-sdk = "0.37"
 tokio = "1"
 gloo-net = "0.5"
+gloo-timers = { version = "0.2", features = ["futures"] }
 futures = "0.3"
 wasm-bindgen-futures = "0.4"
 serde_json="1.0.133"
 thiserror = "2.0.9"
 zerofrom = "0.1"
+mio = "0.8" 
+chrono = "0.4"
+urlencoding = "2.1.2"
 
 [features]
+default = ["ssr"]
 csr = ["leptos/csr", "leptos_meta/csr", "leptos_router/csr"]
 hydrate = ["leptos/hydrate", "leptos_meta/hydrate", "leptos_router/hydrate"]
 ssr = [
@@ -38,8 +45,15 @@ ssr = [
   "leptos/ssr",
   "leptos_meta/ssr",
   "leptos_router/ssr",
+  "dep:rusqlite"
 ]
 
+# Override secp256k1's default features
+[dependencies.secp256k1]
+version = "0.30.0"
+default-features = false
+features = ["rand"]
+
 # Defines a size-optimized profile for the WASM bundle in release mode
 [profile.wasm-release]
 inherits = "release"

README.md

@@ -1,6 +1,7 @@
-# CompareWare
+# [CompareWare](https://compareware.org/)
 
-CompareWare is an open-source platform for comparing tools (software, hardware, etc.) with structured, crowdsourced data. It combines **Leptos** for a modern, reactive frontend and **Nostr** for decentralized data storage.
+CompareWare is an open-source platform for comparing tools (software, hardware, etc.) with structured, crowdsourced data.
+It combines Rust's **Leptos** for a modern, reactive frontend and **Nostr** for decentralized data storage (TBI).
 
 ## **Features**
 - **Item Management**: Add, view, and manage items with metadata and key-value tags.
@@ -25,86 +26,105 @@ CompareWare is an open-source platform for comparing tools (software, hardware,
    ```bash
    cargo leptos serve
    ```
-3. Open your browser at [http://localhost:3000](http://localhost:3000)
+3. Open your browser at [localhost:3000](http://localhost:3000)
 
-## **Roadmap**
+## **Database Schema**
+### Key Concepts
+- **PK (Primary Key)**: Unique identifier for table records (🔑)
+- **FK (Foreign Key)**: Reference linking related tables (➡️)
+- **Core (core properties)**: name and description.
 
-1. **Item Management** (In progress)
-   - Implement a form (`item_form.rs`) to allow users to add new items with metadata and key-value tags.
-   - Create a listing component (`items_list.rs`) to display and manage added items.
-   - Add backend functionality to validate and persist items using the Leptos framework.
+### Tables Overview
 
-2. **Nostr Integration** (In progress)
-   - Use Nostr events for decentralized data storage, mapping item data to specific Nostr event types.
-   - Authenticate users through their Nostr keys for secure and decentralized access.
-   - Enable data sharing and synchronization with Nostr-compatible clients.
+| Table | Columns (PK/FK) | Description | Example Data |
+|-------|------------------|-------------|--------------|
+| **urls** | `id` (PK), `url`, `created_at` | Stores comparison URLs | `1, "/laptops", 2024-03-01` |
+| **items** | `id` (PK), `url_id` (FK), `wikidata_id` | Comparison items | `"item1", 1, "Q214276"` |
+| **properties** | `id` (PK), `name` | All available properties (including core) | `1.0, "name"`<br>`2.0, "description"`<br>`3.0, "screen_size"` |
+| **item_properties** | `item_id` (PK/FK), `property_id` (PK/FK), `value` | All property values including name/description | `"item1", 1.0, "MacBook Pro"`<br>`"item1", 2.0, "16-inch laptop"`<br>`"item1", 3.0, "16 inches"` |
+| **selected_properties** | `url_id` (PK/FK), `property_id` (PK/FK) | Active properties per URL (excludes core) | `1, 3.0` |
 
+### Data Flow
+```mermaid
+flowchart LR
+    User -->|Creates| urls
+    User -->|Adds| items
+    User -->|Defines| properties
+    User -->|Selects| selected_properties
+    User -->|Sets Values| item_properties
+    
+    urls -->|url_id| items
+    urls -->|url_id| selected_properties
+    properties -->|property_id| selected_properties
+    items -->|item_id| item_properties
+    properties -->|property_id| item_properties
+```
 
-## **Compareware: Next Steps**
+### Properties data flow
+```mermaid
+sequenceDiagram
+    participant User
+    participant App as Application
+    participant Wikidata
 
-Here’s how I intend to break down the vision into actionable steps to build upon the current codebase I’ve already built:
+    User->>App: Enters search
+    App->>Wikidata: fetch_wikidata_suggestions()
+    Wikidata-->>App: Return suggestions
+    App->>User: Show suggestions
+    
+    User->>App: Selects item
+    App->>Wikidata: fetch_item_properties()
+    Wikidata-->>App: Return properties (IDs + values)
+    
+    App->>Wikidata: fetch_property_labels()
+    Wikidata-->>App: Return labels
+    App->>App: Combine labels + properties
+    App->>User: Show labeled properties
+```
+## **Docker Deployment**
 
-### **Immediate Steps**
+### **Prerequisites**
+- Docker installed on your system
+- Docker Compose (usually included with Docker Desktop)
 
-#### **Basic Interface (Spreadsheet-like):**
-- Create a grid-based UI to represent items and their properties.
-- Use rows for properties and columns for items.
-- Leverage a Leptos-based table or a custom grid component for rendering.
+### **Running with Docker**
+1. Clone the repository:
+   ```bash
+   git clone https://forge.ftt.gmbh/ryanmwangi/Compware.git
+   cd compareware
+   ```
+2. Start the container:
+   ```bash
+   docker-compose up -d
+   ```
+3. Access the application at: [http://localhost:3000](http://localhost:3000)
 
-#### **Autocompletion for Adding Items and Properties:**
-- Integrate Wikidata's search API to provide autocompletion for item and property inputs.
-- Add a fallback to redirect users to the Wikidata item creation page when a search fails.
+### **Collaboration**
+We welcome contributions! Here’s how you can help:
 
-#### **Fetching Basic Information:**
-- Use Wikidata's REST API to fetch metadata for newly added items (e.g., description, tags, etc.).
-- Populate these fields in the spreadsheet automatically after adding an item.
+### 1. **Contribute Code**
+   - Fork the repository and create a new branch for your feature or fix.
+   - Ensure your changes are well-tested and include documentation if necessary.
+   - Open a **pull request** describing the changes and why they are useful.
 
----
+### 2. **Report Issues**
+   - If you encounter bugs or have suggestions, please open an issue on the [Issues page](https://forge.ftt.gmbh/ryanmwangi/Compware/issues).
+   - Provide as much detail as possible, including steps to reproduce the issue and relevant error messages.
 
-### **Building on the Current Code**
+### 3. **Feature Suggestions**
+   - We are constantly looking to improve CompareWare. If you have ideas for new features, please share them in the Issues section.
+   - You can also help us prioritize future work by commenting or upvoting on existing feature requests.
 
-#### **Enhance the `ItemForm` to Allow:**
-- Searching for existing items via Wikidata.
-- Displaying fetched details in the form.
-- Modify the `handle_submit` function to fetch and populate additional item details after submission.
+### 4. **Documentation Contributions**
+   - If you spot areas in the documentation that need improvement or if you have suggestions for clearer explanations, please feel free to submit a pull request with the updates.
+   - Helping others understand the project is just as valuable as contributing code!
 
-#### **Update the `App` Component to:**
-- Add a placeholder grid view using Leptos’ `view!` macro.
-- Render the comparison grid.
-- Add functionality to fetch items' properties dynamically from Wikidata.
+### 5. **Community and Discussion**
+   - Feel free to ask questions, provide feedback, or engage in discussions related to CompareWare’s development.
 
-#### **Add Wikidata Autocompletion:**
-- Use Gloo's HTTP client to make calls to the Wikidata search API.
+### 6. **Test and Review**
+   - Help by reviewing pull requests to ensure the code meets our standards and is bug-free.
+   - Test new features and provide feedback to improve their functionality and usability.
 
----
+We appreciate any contributions that can help improve CompareWare and make it more useful for the community!
 
-### **Mid-Term Enhancements**
-
-#### **Editable Fields with Wikidata Sync:**
-- Implement field-level editing in the grid.
-- Use Wikidata's APIs to update data directly for logged-in users.
-
-#### **Subjective Properties with Nostr Integration:**
-- Add a toggle for "objective" (Wikidata) vs. "subjective" (Nostr-backed) properties.
-- Store subjective properties locally first and publish them to a Nostr relay for decentralized edits.
-
-#### **Cache Mechanism:**
-- Use a lightweight database (e.g., SQLite or a key-value store like Redis) as a cache for frequently accessed items and properties.
-- Implement cache invalidation for edits to ensure the latest data is fetched.
-
----
-
-### **Advanced Features**
-
-#### **Advanced Filtering and Sorting:**
-- Add functionality to filter items by tags or properties.
-- Enable sorting by property values.
-
-#### **Item Suggestions:**
-- Based on properties and tags, suggest items for comparison.
-
-#### **Collaborative Comparison:**
-- Enable real-time collaboration with WebSockets, allowing users to view and edit comparisons together.
-
-#### **Export/Share Comparison:**
-- Add options to export the comparison as a CSV or share it via a unique link.

ROADMAP.md

@@ -0,0 +1,62 @@
+
+# CompareWare Roadmap
+
+## **Current Features**
+
+These features have been fully implemented:
+
+### **Autocompletion for Adding Items and Properties**
+- Integrated Wikidata's search API to provide autocompletion for item and property inputs.
+
+### **Fetching Basic Information**
+- Used Wikidata's REST API to fetch metadata for newly added items (e.g., description, tags).
+- Automatically populated these fields in the spreadsheet after adding an item.
+
+### **Wikidata Autocompletion**
+- Used Gloo's HTTP client to make calls to the Wikidata search API.
+
+### **App Component Updates**
+- Added a placeholder grid view using Leptos’ `view!` macro.
+- Rendered the comparison grid.
+- Added functionality to fetch items' properties dynamically from Wikidata.
+
+### **Enhance ItemForm**
+- Enabled searching for existing items via Wikidata.
+- Displayed fetched details in the form.
+
+---
+
+## **CompareWare: Next Steps**
+
+### **Immediate Steps**
+
+#### **Autocompletion for Adding Items and Properties:**
+- Fetch all properties for items from wikidata.
+- Autofill propertiy field with available properties for said item.
+- Add a fallback to redirect users to the Wikidata item creation page when a search fails.
+
+### **Authentication**
+- Enable authentication for users using Nsec.app.
+
+#### **Subjective Properties with Nostr Integration:**
+- Add a toggle for "objective" (Wikidata) vs. "subjective" (Nostr-backed) properties.
+- Store subjective properties locally first and publish them to a Nostr relay for decentralized edits.
+
+#### **Cache Mechanism:**
+- Use a lightweight database (e.g., SQLite or a key-value store like Redis) as a cache for frequently accessed items and properties.
+- Implement cache invalidation for edits to ensure the latest data is fetched.
+
+### **Advanced Features**
+
+#### **Advanced Filtering and Sorting:**
+- Add functionality to filter items by tags or properties.
+- Enable sorting by property values.
+
+#### **Item Suggestions:**
+- Based on properties and tags, suggest items for comparison.
+
+#### **Collaborative Comparison:**
+- Enable real-time collaboration with WebSockets, allowing users to view and edit comparisons together.
+
+#### **Export/Share Comparison:**
+- Add options to export the comparison as a CSV or share it via a unique link.

assets/style.css

@@ -68,4 +68,91 @@ th, td {
 
 th {
     background-color: #f2f2f2;
+}
+
+/* Style for the grid container */
+.grid-container {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));  /* Adjust the minimum width for cells */
+    gap: 1px; /* Gap between cells */
+    background-color: #ccc;/* Grid line color  */
+    border: 1px solid #aaa; /* Outer border */
+}
+
+/* Style for individual cells */
+.editable-cell {
+    display: flex;          /* Use flexbox for better layout control */
+    flex-direction: column; /* Stack children vertically */
+    width: 100%;     /* Full width of the allocated space */
+    height: 100%;    /* Full height of the allocated space */
+    position: relative;  /* Relative positioning for absolute children */
+    box-sizing: border-box; /* Ensure padding and border are included in width/height */
+}
+
+/* Style for the input field inside the editable cell */
+.editable-cell-input {
+    width: 100%;    /* Ensure input takes up full width */
+    height: 100%;   /* Ensure input takes up full height */
+    border: none;   /* Remove input box borders */
+    padding: 8px;   /* Add padding for spacing */
+    box-sizing: border-box; /* Ensure padding doesn't cause overflow */
+    font-size: 14px;   /* Adjust font size */
+    text-align: left;  /* Align text to the left */
+    outline: none;     /* Remove outline for better UI */
+    background-color: transparent;  /* Make background transparent */
+}
+
+/* Style for the focused input field */
+.editable-cell-input:focus {
+    background-color: #e0f7fa;  /* Light blue background when focused */
+    border: 1px solid #00796b;  /* Green border when focused */
+}
+
+/* Style for the suggestions list */
+.editable-cell-suggestions {
+    position: absolute;     /* Position suggestions absolutely within the cell */
+    top: 100%;              /* Place suggestions below the input field */
+    left: 0;                /* Align suggestions with the left edge of the cell */
+    width: 100%;            /* Full width of the cell */
+    max-height: 200px;      /* Limit height of suggestions list */
+    overflow-y: auto;       /* Add scrollbar if suggestions exceed max height */
+    background-color: white; /* White background for suggestions */
+    border: 1px solid #ddd;  /* Light border for suggestions */
+    z-index: 10;            /* Ensure suggestions appear above other content */
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1); /* Add shadow for better visibility */
+}
+
+/* Style for individual suggestion items */
+.editable-cell-suggestions li {
+    padding: 8px;           /* Add padding for spacing */
+    cursor: pointer;        /* Change cursor to pointer on hover */
+    border-bottom: 1px solid #eee; /* Add separator between items */
+}
+
+.editable-cell-suggestions li:hover {
+    background-color: #f5f5f5; /* Light gray background on hover */
+}
+
+.search-icon {
+    margin-left: 10px;
+    padding: 5px;
+    border: none;
+    background-color: transparent;
+    cursor: pointer;
+}
+
+.search-icon i {
+    font-size: 18px;
+    color: #333;
+}
+
+.search-icon i.fas.fa-search {
+    margin-left: 5px;
+}
+
+.editable-cell-textarea {
+    width: 100%;
+    height: 100px;
+    resize: vertical;
+    overflow: auto;
 }

docker-compose.yml

@@ -0,0 +1,11 @@
+services:
+  app:
+    build: .
+    ports:
+      - "3000:3000"
+    volumes:
+      - ./compareware.db:/app/compareware.db
+    environment:
+      - RUST_LOG=info
+      - LEPTOS_ENV=production
+    restart: unless-stopped

dockerfile

@@ -0,0 +1,56 @@
+# Build stage
+FROM rust:1.83.0-slim-bullseye as builder
+
+# Install essential build tools
+RUN apt-get update && \
+    apt-get install -y \
+    libsqlite3-dev \
+    build-essential \
+    clang \
+    libssl-dev \
+    pkg-config \
+    curl \
+    cmake \
+    protobuf-compiler \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Rust toolchain
+RUN rustup component add rust-src
+
+# Install cargo-leptos & wasm-bindgen-cli 
+RUN cargo install cargo-leptos --version 0.2.24 --locked
+RUN cargo install wasm-bindgen-cli --version 0.2.99 --locked
+
+# Build application
+WORKDIR /app
+COPY . .
+# Explicitly set WASM target
+RUN rustup target add wasm32-unknown-unknown
+# Build project
+ENV LEPTOS_OUTPUT_NAME="compareware"
+
+# Build with release profile
+RUN cargo leptos build --release
+
+# Runtime stage
+FROM debian:bullseye-slim 
+
+# Install runtime dependencies in Debian
+RUN apt-get update && \
+    apt-get install -y \
+    libssl-dev \
+    libsqlite3-0 \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy build artifacts
+COPY --from=builder /app/target/release/compareware /app/
+COPY --from=builder /app/target/site /app/site
+COPY assets /app/assets
+
+# Configure container, expose port and set entrypoint
+WORKDIR /app 
+EXPOSE 3000
+ENV LEPTOS_SITE_ADDR=0.0.0.0:3000
+ENV LEPTOS_SITE_ROOT="site"
+CMD ["./compareware"]

rust-toolchain.toml

@@ -1,2 +1,3 @@
 [toolchain]
-channel = "1.83.0"
+channel = "1.82.0"
+targets = [ "wasm32-unknown-unknown" ]

src/api.rs

@@ -0,0 +1,182 @@
+#[cfg(feature = "ssr")]
+use actix_web::{web, HttpResponse};
+#[cfg(feature = "ssr")]
+use crate::db::Database;
+#[cfg(feature = "ssr")]
+use std::sync::Arc;
+#[cfg(feature = "ssr")]
+use tokio::sync::Mutex;
+#[cfg(feature = "ssr")]
+use crate::models::item::Item;
+#[cfg(feature = "ssr")]
+use std::collections::HashMap;
+#[cfg(feature = "ssr")]
+use leptos::logging::log;
+
+#[cfg(feature = "ssr")]
+use serde::{Deserialize, Serialize};
+#[cfg(feature = "ssr")]
+#[derive(Serialize, Deserialize)]
+pub struct ItemRequest {
+    pub url: String,
+    pub item: Item,
+}
+
+#[cfg(feature = "ssr")]
+pub async fn get_items(
+    db: web::Data<Arc<Mutex<Database>>>,
+    url: web::Query<String>,
+) -> HttpResponse {
+    log!("[SERVER] Received request for URL: {}", url);
+
+    let db = db.lock().await;
+    match db.get_items_by_url(&url).await {
+        Ok(items) => {
+            log!("[SERVER] Returning {} items for URL: {}", items.len(), url);
+            HttpResponse::Ok().json(items)
+        },
+        Err(err) => {
+            log!("[SERVER ERROR] Failed to fetch items for {}: {:?}", url, err);
+            HttpResponse::InternalServerError().body("Failed to fetch items")
+        }
+    }
+}
+
+#[cfg(feature = "ssr")]
+pub async fn create_item(
+    db: web::Data<Arc<Mutex<Database>>>,
+    request: web::Json<ItemRequest>,
+) -> HttpResponse {
+    let db = db.lock().await;
+    let url = request.url.clone();
+    let item = request.item.clone();
+    let item_id = request.item.id.clone();
+    // request logging
+    log!("[API] Received item request - URL: {}, Item ID: {}", 
+        request.url, request.item.id);
+    
+    // raw JSON logging
+    let raw_json = serde_json::to_string(&request.into_inner()).unwrap();
+    log!("[API] Raw request JSON: {}", raw_json);
+
+    match db.insert_item_by_url(&url, &item).await {
+        Ok(_) => {
+            log!("[API] Successfully saved item ID: {}", item_id);
+            HttpResponse::Ok().json(item)
+        },
+        Err(e) => {
+            log!("[API] Database error: {:?}", e); 
+            HttpResponse::BadRequest().body(format!("Database error: {}", e))
+        }
+    }
+}
+
+#[cfg(feature = "ssr")]
+pub async fn delete_item(
+    db: web::Data<Arc<Mutex<Database>>>,
+    path: web::Path<(String, String)>, // (url, item_id)
+) -> HttpResponse {
+    let (url, item_id) = path.into_inner();
+    log!("[API] Deleting item {} from URL {}", item_id, url);
+    let db = db.lock().await;
+    match db.delete_item_by_url(&url, &item_id).await {
+        Ok(_) => HttpResponse::Ok().finish(),
+        Err(e) => {
+            log!("[API] Delete error: {:?}", e);
+            HttpResponse::InternalServerError().body(e.to_string())
+        }
+    }
+}
+
+#[cfg(feature = "ssr")]
+pub async fn delete_property(
+    db: web::Data<Arc<Mutex<Database>>>,
+    path: web::Path<(String, String)>, // (url, property)
+) -> HttpResponse {
+    let (url, property) = path.into_inner();
+    log!("[API] Deleting property {} from URL {}", property, url);
+    let db = db.lock().await;
+    match db.delete_property_by_url(&url, &property).await {
+        Ok(_) => HttpResponse::Ok().finish(),
+        Err(e) => {
+            log!("[API] Delete error: {:?}", e);
+            HttpResponse::InternalServerError().body(e.to_string())
+        }
+    }
+}
+
+#[cfg(feature = "ssr")]
+pub async fn get_items_by_url(
+    db: web::Data<Arc<Mutex<Database>>>,
+    query: web::Query<HashMap<String, String>>,
+) -> HttpResponse {
+    let url = query.get("url").unwrap_or(&String::new()).to_string();
+    let db = db.lock().await;
+    match db.get_items_by_url(&url).await {
+        Ok(items) => HttpResponse::Ok().json(items),
+        Err(err) => {
+            leptos::logging::error!("Failed to fetch items by URL: {:?}", err);
+            HttpResponse::InternalServerError().body("Failed to fetch items by URL")
+        }
+    }
+}
+
+#[cfg(feature = "ssr")]
+pub async fn delete_item_by_url(
+    db: web::Data<Arc<Mutex<Database>>>,
+    url: web::Path<String>,
+    item_id: web::Path<String>,
+) -> HttpResponse {
+    let db = db.lock().await;
+    match db.delete_item_by_url(&url, &item_id).await {
+        Ok(_) => HttpResponse::Ok().body("Item deleted"),
+        Err(err) => {
+            leptos::logging::error!("Failed to delete item by URL: {:?}", err);
+            HttpResponse::InternalServerError().body("Failed to delete item by URL")
+        }
+    }
+}
+
+#[cfg(feature = "ssr")]
+pub async fn delete_property_by_url(
+    db: web::Data<Arc<Mutex<Database>>>,
+    url: web::Path<String>,
+    property: web::Path<String>,
+) -> HttpResponse {
+    let db = db.lock().await;
+    match db.delete_property_by_url(&url, &property).await {
+        Ok(_) => HttpResponse::Ok().body("Property deleted"),
+        Err(err) => {
+            leptos::logging::error!("Failed to delete property by URL: {:?}", err);
+            HttpResponse::InternalServerError().body("Failed to delete property by URL")
+        }
+    }
+}
+
+#[cfg(feature = "ssr")]
+pub async fn get_selected_properties(
+    db: web::Data<Arc<Mutex<Database>>>,
+    url: web::Path<String>,
+) -> HttpResponse {
+    let db = db.lock().await;
+    match db.get_selected_properties(&url).await {
+        Ok(properties) => HttpResponse::Ok().json(properties),
+        Err(e) => HttpResponse::InternalServerError().body(e.to_string())
+    }
+}
+
+#[cfg(feature = "ssr")]
+pub async fn add_selected_property(
+    db: web::Data<Arc<Mutex<Database>>>,
+    url: web::Path<String>,
+    property: web::Json<String>,
+) -> HttpResponse {
+    let url = url.into_inner();
+    let property = property.into_inner();
+    
+    let db = db.lock().await;
+    match db.add_selected_property(&url, &property).await {
+        Ok(_) => HttpResponse::Ok().finish(),
+        Err(e) => HttpResponse::InternalServerError().body(e.to_string())
+    }
+}

src/app.rs

@@ -1,11 +1,13 @@
 use leptos::*;
 use leptos_meta::*;
-use crate::components::items_list::ItemsList;
+use leptos_router::*; 
+use leptos::logging::log;
+use crate::components::items_list::{ItemsList, load_items_from_db};
 use crate::models::item::Item;
-use crate::nostr::NostrClient;
-use tokio::sync::mpsc;
 use leptos::spawn_local;
-use nostr_sdk::serde_json;
+// use tokio::sync::mpsc;
+// use crate::nostr::NostrClient;
+// use nostr_sdk::serde_json;
 
 #[component]
 pub fn App() -> impl IntoView {
@@ -13,25 +15,49 @@ pub fn App() -> impl IntoView {
 
     // Signal to manage the list of items
     let (items_signal, set_items) = create_signal(Vec::<Item>::new());
-    let (tx, mut rx) = mpsc::channel::<String>(100);
+    // let (tx, mut rx) = mpsc::channel::<String>(100);
 
-    // Nostr client subscription for items
-    spawn_local(async move {
-        let nostr_client = NostrClient::new("wss://relay.example.com").await.unwrap();
-        nostr_client.subscribe_to_items(tx.clone()).await.unwrap();
-
-        while let Some(content) = rx.recv().await {
-            if let Ok(item) = serde_json::from_str::<Item>(&content) {
-                set_items.update(|items| items.push(item));
-            }
-        }
-    });
+    // // Nostr client subscription for items
+    // spawn_local(async move {
+    //     let nostr_client = NostrClient::new("wss://relay.example.com").await.unwrap();
+    //     nostr_client.subscribe_to_items(tx.clone()).await.unwrap();
 
+    //     while let Some(content) = rx.recv().await {
+    //         if let Ok(item) = serde_json::from_str::<Item>(&content) {
+    //             set_items.update(|items| items.push(item));
+    //         }
+    //     }
+    // });
     view! {
-        <Stylesheet href="/assets/style.css" />
-        <div>
-            <h1>{ "CompareWare" }</h1>
-            <ItemsList items=items_signal set_items=set_items />
-        </div>
+        <Router>
+            <Routes>
+                <Route path="/*url" view=move || {
+                    let location = use_location();
+                    let current_url = move || location.pathname.get();
+                    
+                    // Proper async handling
+                    spawn_local({
+                        let current_url = current_url.clone();
+                        async move {
+                            match load_items_from_db(&current_url()).await {
+                                Ok(items) => set_items.set(items),
+                                Err(e) => log!("Error loading items: {}", e),
+                            }
+                        }
+                    });
+                    view! {
+                        <Stylesheet href="/assets/style.css" />
+                        <Stylesheet href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.1.1/css/all.min.css" />
+                        <div>
+                            <h1>{ "CompareWare" }</h1>
+                            <ItemsList 
+                            url=current_url() 
+                            items=items_signal 
+                            set_items=set_items />
+                        </div>
+                    }
+                }/>
+            </Routes>
+        </Router>
     }
 }

src/components/editable_cell.rs

@@ -1,39 +1,101 @@
 use leptos::*;
+use std::sync::Arc;
+use leptos::logging::log;
 
 #[component]
 pub fn EditableCell(
     value: String,
     on_input: impl Fn(String) + 'static,
-    #[prop(optional)] key: Option<String>, // Optional `key` prop
+    key: Arc<String>,
+    focused_cell: ReadSignal<Option<String>>,
+    set_focused_cell: WriteSignal<Option<String>>,
+    on_focus: Option<Callback<()>>,
+    on_blur: Option<Callback<()>>,
+    input_type: InputType,
 ) -> impl IntoView {
-    let (input_value, set_input_value) = create_signal(value.clone());
-    let (has_focus, set_has_focus) = create_signal(false); // Track focus state locally
-
+    let input_ref = create_node_ref::<html::Input>();
+    let textarea_ref = create_node_ref::<html::Textarea>();
+    let (local_value, set_local_value) = create_signal(value.clone());
+    let input_type_clone = input_type.clone();
+    // Handle input event
     let handle_input = move |e: web_sys::Event| {
-        let new_value = event_target_value(&e);
-        set_input_value.set(new_value.clone());
-        on_input(new_value);
+        let new_value = match input_type_clone {
+            InputType::Text => event_target_value(&e),
+            InputType::TextArea => event_target_value(&e),
+        };
+        log!("Input event: {}", new_value);
+        set_local_value.set(new_value);
     };
 
-    let handle_focus = move |_: web_sys::FocusEvent| {
-        set_has_focus.set(true);
+    // Commit the input value on blur or enter
+    let commit_input = move || {
+        let value = local_value.get();
+        log!("Committing input: {}", value);
+        on_input(value);
     };
 
-    let handle_blur = move |_: web_sys::FocusEvent| {
-        set_has_focus.set(false);
+    // Focus handling
+    let handle_focus = {
+        let key = Arc::clone(&key);
+        move |_| {
+            log!("Focus gained for key: {}", key);
+            set_focused_cell.set(Some(key.to_string()));
+            if let Some(on_focus) = &on_focus {
+                on_focus.call(());
+            }
+        }
     };
 
-    // Use key to force updates only when necessary
-    let _key = key.unwrap_or_default();
+    let handle_blur = move |_| {
+        log!("Focus lost");
+        set_focused_cell.set(None);
+        commit_input();
+        if let Some(on_blur) = &on_blur {
+            on_blur.call(());
+        }
+    };
+
+    // Update input field value when focused cell changes
+    create_effect(move |_| {
+        if focused_cell.get().as_deref() == Some(key.as_str()) {
+            log!("Setting focus for key: {}", key);
+            if let Some(input) = input_ref.get() {
+                let _ = input.focus();
+            }
+        }
+    });
 
     view! {
-        <input
-            type="text"
-            value={input_value.get()}
-            on:input=handle_input
-            on:focus=handle_focus
-            on:blur=handle_blur
-            class={if has_focus.get() { "focused" } else { "not-focused" }}
-        />
+        <div class="editable-cell">
+            {match input_type {
+                InputType::Text => view! {
+                    <input
+                        type="text"
+                        prop:value=move || local_value.get()
+                        on:input=handle_input
+                        on:focus=handle_focus
+                        on:blur=handle_blur
+                        node_ref=input_ref
+                        class="editable-cell-input"
+                    />
+                }.into_view(),
+                InputType::TextArea => view! {
+                    <textarea
+                        prop:value=move || local_value.get()
+                        on:input=handle_input
+                        on:focus=handle_focus
+                        on:blur=handle_blur
+                        node_ref=textarea_ref
+                        class="editable-cell-input"
+                    />
+                }.into_view()
+            }}
+        </div>
     }
 }
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum InputType {
+    Text,
+    TextArea,
+}

src/components/item_form.rs

@@ -1,74 +0,0 @@
-use leptos::*;
-use leptos_dom::ev::SubmitEvent;
-use leptos::logging::log;
-
-#[component]
-pub fn ItemForm(on_submit: Box<dyn Fn(String, String, Vec<(String, String)>, String, u8)>) -> impl IntoView {
-    let (name, set_name) = create_signal(String::new());
-    let (description, set_description) = create_signal(String::new());
-    let (tags, set_tags) = create_signal(Vec::<(String, String)>::new());
-    let (tag_key, set_tag_key) = create_signal(String::new());
-    let (tag_value, set_tag_value) = create_signal(String::new());
-    let (review, set_review) = create_signal(String::new());
-    let (rating, set_rating) = create_signal(5u8); // Default rating to 5
-
-    let add_tag = move |_| {
-        if !tag_key.get().is_empty() && !tag_value.get().is_empty() {
-            set_tags.update(|t| t.push((tag_key.get(), tag_value.get())));
-            set_tag_key.set(String::new());
-            set_tag_value.set(String::new());
-        }
-    };
-
-    let handle_submit = move |ev: SubmitEvent| {
-        ev.prevent_default();
-
-         // Validation
-         if name.get().is_empty() || description.get().is_empty() || rating.get() < 1 || rating.get() > 5 {
-            log!("Validation failed: Check required fields.");
-            return;
-        }
-
-        on_submit(
-            name.get(),
-            description.get(),
-            tags.get().clone(),
-            review.get(),
-            rating.get(),
-        );
-
-        // Reset values
-        set_name.set(String::new());
-        set_description.set(String::new());
-        set_tags.set(vec![]);
-        set_review.set(String::new());
-        set_rating.set(5);
-    };
-
-    view! {
-        <form on:submit=handle_submit>
-            <input type="text" placeholder="Name" on:input=move |e| set_name.set(event_target_value(&e)) />
-            <textarea placeholder="Description" on:input=move |e| set_description.set(event_target_value(&e)) />
-            <h3>{ "Add Tags" }</h3>
-            <input type="text" placeholder="Key" on:input=move |e| set_tag_key.set(event_target_value(&e)) />
-            <input type="text" placeholder="Value" on:input=move |e| set_tag_value.set(event_target_value(&e)) />
-            <button type="button" on:click=add_tag>{ "Add Tag" }</button>
-            <ul>
-                {tags.get().iter().map(|(key, value)| view! {
-                    <li>{ format!("{}: {}", key, value) }</li>
-                }).collect::<Vec<_>>() }
-            </ul>
-            <h3>{ "Write a Review" }</h3>
-            <textarea placeholder="Review" on:input=move |e| set_review.set(event_target_value(&e)) />
-            <h3>{ "Rating (1-5)" }</h3>
-            <input
-                type="number"
-                min="1"
-                max="5"
-                value={rating.get()}
-                on:input=move |e| set_rating.set(event_target_value(&e).parse::<u8>().unwrap_or(5))
-            />
-            <button type="submit">{ "Add Item" }</button>
-        </form>
-    }
-}

src/components/mod.rs

@@ -1,4 +1,2 @@
-pub mod item_form;
 pub mod items_list;
-pub mod editable_cell;
-pub mod tag_editor;
+pub mod editable_cell;

src/components/tag_editor.rs

@@ -1,54 +0,0 @@
-use leptos::*;
-use std::sync::{Arc, Mutex};
-
-
-
-#[component]
-pub fn TagEditor(
-    tags: Vec<(String, String)>,
-    on_add: impl Fn(String, String) + 'static,
-    on_remove: Arc<Mutex<dyn FnMut(usize) + Send + Sync>>,
-) -> impl IntoView {
-    let (key, set_key) = create_signal(String::new());
-    let (value, set_value) = create_signal(String::new());
-
-    let add_tag = move |_| {
-        if !key.get().is_empty() && !value.get().is_empty() {
-            on_add(key.get(), value.get());
-            set_key.set(String::new());
-            set_value.set(String::new());
-        }
-    };
-
-    view! {
-        <div>
-            <ul>
-                {tags.iter().enumerate().map(|(index, (k, v))| {
-                    let on_remove = on_remove.clone();
-                    view! {
-                        <li>
-                            {format!("{}: {}", k, v)}
-                            <button on:click=move |_| {
-                                let mut on_remove = on_remove.lock().unwrap();
-                                on_remove(index);
-                            }>
-                            { "Remove" }
-                            </button>
-                        </li>
-                    }
-                }).collect::<Vec<_>>()}
-            </ul>
-            <input
-                placeholder="Key"
-                value={key.get()}
-                on:input=move |e| set_key.set(event_target_value(&e))
-            />
-            <input
-                placeholder="Value"
-                value={value.get()}
-                on:input=move |e| set_value.set(event_target_value(&e))
-            />
-            <button on:click=add_tag>{ "Add Tag" }</button>
-        </div>
-    }
-}

src/components/wikidata_lookup.rs

@@ -1,48 +0,0 @@
-use leptos::*;
-use serde::Deserialize;
-
-#[derive(Deserialize, Clone, Debug)]
-struct WikidataResult {
-    id: String,
-    label: String,
-    description: Option<String>,
-}
-
-#[component]
-pub fn WikidataLookup(
-    query: String,
-    on_select: impl Fn(WikidataResult) + 'static,
-) -> impl IntoView {
-    let (suggestions, set_suggestions) = create_signal(Vec::new());
-
-    let fetch_suggestions = move |query: String| {
-        spawn_local(async move {
-            if query.is_empty() {
-                set_suggestions(Vec::new());
-                return;
-            }
-            let url = format!("https://www.wikidata.org/w/api.php?action=wbsearchentities&search={}&language=en&limit=5&format=json&origin=*", query);
-            if let Ok(response) = reqwest::get(&url).await {
-                if let Ok(data) = response.json::<WikidataResponse>().await {
-                    set_suggestions(data.search);
-                }
-            }
-        });
-    };
-
-    create_effect(move || {
-        fetch_suggestions(query.clone());
-    });
-
-    view! {
-        <ul>
-            {suggestions.get().iter().map(|suggestion| {
-                view! {
-                    <li on:click=move |_| on_select(suggestion.clone())>
-                        {format!("{} - {}", suggestion.label, suggestion.description.clone().unwrap_or_default())}
-                    </li>
-                }
-            }).collect::<Vec<_>>()}
-        </ul>
-    }
-}

src/db.rs

@@ -0,0 +1,784 @@
+#[cfg(feature = "ssr")]
+mod db_impl {
+    use crate::models::item::Item;
+    use leptos::logging;
+    use leptos::logging::log;
+    use rusqlite::{Connection, Error};
+    use serde::{Deserialize, Serialize};
+    use std::collections::{HashMap, HashSet};
+    use std::sync::Arc;
+    use tokio::sync::Mutex;
+    use uuid::Uuid;
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+        use tokio::runtime::Runtime;
+        use uuid::Uuid;
+
+        // Helper function to create test database
+        async fn create_test_db() -> Database {
+            log!("[TEST] Creating in-memory test database");
+            let db = Database::new(":memory:").unwrap();
+            db.create_schema().await.unwrap();
+            log!("[TEST] Database schema created");
+            db
+        }
+
+        // Test database schema creation
+        #[tokio::test]
+        async fn test_schema_creation() {
+            log!("[TEST] Starting test_schema_creation");
+            let db = create_test_db().await;
+
+            // Verify tables exist
+            let conn = db.conn.lock().await;
+            let mut stmt = conn
+                .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+                .unwrap();
+            let tables: Vec<String> = stmt
+                .query_map([], |row| row.get(0))
+                .unwrap()
+                .collect::<Result<_, _>>()
+                .unwrap();
+
+            assert!(tables.contains(&"urls".to_string()));
+            assert!(tables.contains(&"items".to_string()));
+            assert!(tables.contains(&"properties".to_string()));
+            assert!(tables.contains(&"item_properties".to_string()));
+            assert!(tables.contains(&"selected_properties".to_string()));
+        }
+
+        // Item Lifecycle Tests
+        #[tokio::test]
+        async fn test_full_item_lifecycle() {
+            log!("[TEST] Starting test_full_item_lifecycle");
+            let db = create_test_db().await;
+            let test_url = "https://example.com";
+            let test_item = Item {
+                id: Uuid::new_v4().to_string(),
+                name: "Test Item".into(),
+                description: "Test Description".into(),
+                wikidata_id: Some("Q123".into()),
+                custom_properties: vec![
+                    ("price".into(), "100".into()),
+                    ("color".into(), "red".into()),
+                ]
+                .into_iter()
+                .collect(),
+            };
+
+            // Test insertion
+            log!("[TEST] Testing item insertion");
+            db.insert_item_by_url(test_url, &test_item).await.unwrap();
+            log!("[TEST] Item insertion - PASSED");
+
+            // Test retrieval
+            log!("[TEST] Testing item retrieval");
+            let items = db.get_items_by_url(test_url).await.unwrap();
+            assert_eq!(items.len(), 1);
+            let stored_item = &items[0];
+            assert_eq!(stored_item.name, test_item.name);
+            assert_eq!(stored_item.custom_properties.len(), 2);
+            log!("[TEST] Item retrieval and validation - PASSED");
+
+            // Test update
+            log!("[TEST] Testing item update");
+            let mut updated_item = test_item.clone();
+            updated_item.name = "Updated Name".into();
+            db.insert_item_by_url(test_url, &updated_item)
+                .await
+                .unwrap();
+
+            // Verify update
+            let items = db.get_items_by_url(test_url).await.unwrap();
+            assert_eq!(items[0].name, "Updated Name");
+            log!("[TEST] Item update - PASSED");
+
+            // Test deletion
+            log!("[TEST] Testing item deletion");
+            db.delete_item_by_url(test_url, &test_item.id)
+                .await
+                .unwrap();
+            let items = db.get_items_by_url(test_url).await.unwrap();
+            assert!(items.is_empty());
+            log!("[TEST] Item deletion - PASSED");
+            log!("[TEST] test_full_item_lifecycle completed successfully");
+        }
+
+        //URL Management Tests
+        #[tokio::test]
+        async fn test_url_management() {
+            log!("[TEST] Starting test_url_management");
+            let db = create_test_db().await;
+            let test_url = "https://test.com";
+
+            // Test URL creation
+            log!("[TEST] Testing URL creation");
+            let url_id = db.insert_url(test_url).await.unwrap();
+            assert!(url_id > 0);
+            log!("[TEST] URL creation - PASSED");
+
+            // Test duplicate URL handling
+            log!("[TEST] Testing duplicate URL handling");
+            let duplicate_id = db.insert_url(test_url).await.unwrap();
+            assert_eq!(url_id, duplicate_id);
+            log!("[TEST] Duplicate URL handling - PASSED");
+
+            // Test URL retrieval
+            log!("[TEST] Testing URL retrieval");
+            let conn = db.conn.lock().await;
+            let stored_url: String = conn
+                .query_row("SELECT url FROM urls WHERE id = ?", [url_id], |row| {
+                    row.get(0)
+                })
+                .unwrap();
+            assert_eq!(stored_url, test_url);
+            log!("[TEST] URL retrieval - PASSED");
+
+            log!("[TEST] test_url_management completed successfully");
+        }
+
+        //property management tests
+        #[tokio::test]
+        async fn test_property_operations() {
+            log!("[TEST] Starting test_property_operations");
+            let db = create_test_db().await;
+            let test_url = "https://props.com";
+            let test_item = Item {
+                id: Uuid::new_v4().to_string(),
+                name: "Test Item".into(),
+                description: "Test Description".into(),
+                wikidata_id: Some("Q123".into()),
+                custom_properties: vec![
+                    ("price".into(), "100".into()),
+                    ("color".into(), "red".into()),
+                ]
+                .into_iter()
+                .collect(),
+            };
+            // Test property creation
+            log!("[TEST] Testing property creation");
+            db.insert_item_by_url(test_url, &test_item).await.unwrap();
+
+            // Verify properties stored
+            let items = db.get_items_by_url(test_url).await.unwrap();
+            assert_eq!(items[0].custom_properties.len(), 2);
+            log!("[TEST] Property creation - PASSED");
+
+            // Test property deletion
+            log!("[TEST] Testing property deletion");
+            db.delete_property_by_url(test_url, "price").await.unwrap();
+            let items = db.get_items_by_url(test_url).await.unwrap();
+            assert_eq!(items[0].custom_properties.len(), 1);
+            assert!(!items[0].custom_properties.contains_key("price"));
+            log!("[TEST] Property deletion - PASSED");
+
+            log!("[TEST] test_property_operations completed successfully");
+        }
+
+        //selected properties test
+        #[tokio::test]
+        async fn test_selected_properties() {
+            log!("[TEST] Starting test_selected_properties");
+            let db = create_test_db().await;
+            let test_url = "https://selected.com";
+
+            // Add test properties
+            log!("[TEST] Adding selected properties");
+            db.add_selected_property(test_url, "price").await.unwrap();
+            db.add_selected_property(test_url, "weight").await.unwrap();
+
+            // Test retrieval
+            log!("[TEST] Testing property retrieval");
+            let props = db.get_selected_properties(test_url).await.unwrap();
+            assert_eq!(props.len(), 2);
+            assert!(props.contains(&"price".to_string()));
+            assert!(props.contains(&"weight".to_string()));
+            log!("[TEST] Property retrieval - PASSED");
+
+            // Test duplicate prevention
+            log!("[TEST] Testing duplicate prevention");
+            db.add_selected_property(test_url, "price").await.unwrap();
+            let props = db.get_selected_properties(test_url).await.unwrap();
+            assert_eq!(props.len(), 2); // No duplicate added
+            log!("[TEST] Duplicate prevention - PASSED");
+
+            log!("[TEST] test_selected_properties completed successfully");
+        }
+    }
+
+    // Define a struct to represent a database connection
+    #[derive(Debug)]
+    pub struct Database {
+        conn: Arc<Mutex<Connection>>,
+    }
+
+    impl Database {
+        // Create a new database connection
+        pub fn new(db_path: &str) -> Result<Self, Error> {
+            let conn = Connection::open(db_path)?;
+            logging::log!("Database connection established at: {}", db_path);
+            Ok(Database {
+                conn: Arc::new(Mutex::new(conn)),
+            })
+        }
+
+        // Create the database schema
+        pub async fn create_schema(&self) -> Result<(), Error> {
+            let conn = self.conn.lock().await;
+
+            // 1. Properties table
+            conn.execute_batch(
+                "CREATE TABLE IF NOT EXISTS properties (
+                    id INTEGER PRIMARY KEY,
+                    name TEXT NOT NULL UNIQUE, 
+                    global_usage_count INTEGER DEFAULT 0
+                );",
+            )
+            .map_err(|e| {
+                eprintln!("Failed creating properties table: {}", e);
+                e
+            })?;
+
+            // 2. URLs table
+            conn.execute_batch(
+                "CREATE TABLE IF NOT EXISTS urls (
+                    id INTEGER PRIMARY KEY,
+                    url TEXT NOT NULL UNIQUE,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                );",
+            )
+            .map_err(|e| {
+                eprintln!("Failed creating urls table: {}", e);
+                e
+            })?;
+
+            // 3. Items table
+            conn.execute_batch(
+                "CREATE TABLE IF NOT EXISTS items (
+                    id TEXT PRIMARY KEY,
+                    url_id INTEGER NOT NULL,
+                    wikidata_id TEXT,
+                    item_order INTEGER NOT NULL DEFAULT 0,
+                    FOREIGN KEY (url_id) REFERENCES urls(id) ON DELETE CASCADE
+                );
+                INSERT OR IGNORE INTO properties (name) VALUES 
+                ('name'), 
+                ('description');",
+            )
+            .map_err(|e| {
+                eprintln!("Failed creating items table: {}", e);
+                e
+            })?;
+
+            // Check if the global_item_id column exists
+            let mut stmt = conn.prepare("PRAGMA table_info(items);")?;
+            let columns: Vec<String> = stmt
+                .query_map([], |row| row.get(1))? // Column 1 contains the column names
+                .collect::<Result<_, _>>()?;
+
+            if !columns.contains(&"global_item_id".to_string()) {
+                conn.execute_batch(
+                    "ALTER TABLE items ADD COLUMN global_item_id TEXT;"
+                )
+                .map_err(|e| {
+                    eprintln!("Failed adding global_item_id to items table: {}", e);
+                    e
+                })?;
+            }
+
+            // 4. Table for selected properties
+            conn.execute_batch(
+                "CREATE TABLE IF NOT EXISTS selected_properties (
+                    url_id INTEGER NOT NULL,
+                    property_id INTEGER NOT NULL,
+                    PRIMARY KEY (url_id, property_id),
+                    FOREIGN KEY (url_id) REFERENCES urls(id) ON DELETE CASCADE,
+                    FOREIGN KEY (property_id) REFERENCES properties(id) ON DELETE CASCADE
+                );",
+            )
+            .map_err(|e| {
+                eprintln!("Failed creating properties table: {}", e);
+                e
+            })?;
+
+            // 5. Junction table for custom properties
+            conn.execute_batch(
+                "CREATE TABLE IF NOT EXISTS item_properties (
+                    global_item_id TEXT NOT NULL,
+                    property_id INTEGER NOT NULL,
+                    value TEXT NOT NULL,
+                    PRIMARY KEY (global_item_id, property_id),
+                    FOREIGN KEY (global_item_id) REFERENCES items(global_item_id) ON DELETE CASCADE,
+                    FOREIGN KEY (property_id) REFERENCES properties(id) ON DELETE CASCADE
+                );",
+            )
+            .map_err(|e| {
+                eprintln!("Failed creating item_properties table: {}", e);
+                e
+            })?;
+
+            // 6. Junction table for deleted properties
+            conn.execute_batch(
+            "CREATE TABLE IF NOT EXISTS deleted_properties (
+                url_id INTEGER NOT NULL,
+                global_item_id TEXT NOT NULL,
+                property_id INTEGER NOT NULL,
+                PRIMARY KEY (url_id, global_item_id, property_id),
+                FOREIGN KEY (url_id) REFERENCES urls(id) ON DELETE CASCADE,
+                FOREIGN KEY (global_item_id) REFERENCES items(global_item_id) ON DELETE CASCADE,
+                FOREIGN KEY (property_id) REFERENCES properties(id) ON DELETE CASCADE
+                );",
+            ).map_err(|e| {
+                eprintln!("Failed creating item_properties table: {}", e);
+                e
+            })?;
+
+            Ok(())
+        }
+
+        // Insert a new URL into the database
+        pub async fn insert_url(&self, url: &str) -> Result<i64, Error> {
+            let mut conn = self.conn.lock().await;
+            let tx = conn.transaction()?;
+
+            // Use INSERT OR IGNORE to handle duplicates
+            tx.execute("INSERT OR IGNORE INTO urls (url) VALUES (?)", [url])?;
+
+            // Get the URL ID whether it was inserted or already existed
+            let url_id =
+                tx.query_row("SELECT id FROM urls WHERE url = ?", [url], |row| row.get(0))?;
+
+            tx.commit()?;
+            logging::log!("URL inserted: {}", url);
+            Ok(url_id)
+        }
+
+        pub async fn delete_item(&self, item_id: &str) -> Result<(), Error> {
+            let conn = self.conn.lock().await;
+            conn.execute("DELETE FROM items WHERE id = ?", &[item_id])?;
+            logging::log!("Item deleted: {}", item_id);
+            Ok(())
+        }
+
+        pub async fn delete_property(&self, property: &str) -> Result<(), Error> {
+            let conn = self.conn.lock().await;
+            let query = format!(
+                "UPDATE items SET custom_properties = json_remove(custom_properties, '$.{}')",
+                property
+            );
+            conn.execute(&query, []).map_err(|e| Error::from(e))?;
+            logging::log!("Property deleted: {}", property);
+            Ok(())
+        }
+
+        // Retrieve all items from the database
+        pub async fn get_items(&self) -> Result<Vec<DbItem>, Error> {
+            let conn = self.conn.lock().await;
+            let mut stmt = conn.prepare("SELECT * FROM items;")?;
+            let items = stmt.query_map([], |row| {
+                Ok(DbItem {
+                    id: row.get(0)?,
+                    name: row.get(1)?,
+                    description: row.get(2)?,
+                    wikidata_id: row.get(3)?,
+                })
+            })?;
+            let mut result = Vec::new();
+            for item in items {
+                result.push(item?);
+            }
+            logging::log!("Fetched {} items from the database", result.len()); // Log with Leptos
+            Ok(result)
+        }
+
+        // Retrieve all items from the database for a specific URL
+        pub async fn get_items_by_url(&self, url: &str) -> Result<Vec<Item>, Error> {
+            let conn = self.conn.lock().await;
+            let url_id: Option<i64> =
+                match conn.query_row("SELECT id FROM urls WHERE url = ?", &[url], |row| {
+                    row.get(0)
+                }) {
+                    Ok(id) => Some(id),
+                    Err(rusqlite::Error::QueryReturnedNoRows) => None,
+                    Err(e) => return Err(e),
+                };
+
+            let url_id = match url_id {
+                Some(id) => id,
+                None => return Ok(Vec::new()), // Return empty list if URL not found
+            };
+
+            log!("Fetching items for URL '{}' (ID: {})", url, url_id);
+
+            let mut stmt = conn.prepare(
+                "WITH ordered_items AS (
+                    SELECT 
+                        i.id,
+                        i.wikidata_id,
+                        i.item_order,
+                        i.global_item_id 
+                    FROM items i
+                    WHERE i.url_id = ?
+                    ORDER BY i.item_order ASC
+                )
+                SELECT
+                    oi.id,
+                    oi.wikidata_id,
+                    name_ip.value AS name,
+                    desc_ip.value AS description,
+                    json_group_object(p.name, ip.value) as custom_properties
+                FROM ordered_items oi
+                LEFT JOIN item_properties ip 
+                    ON oi.global_item_id = ip.global_item_id
+                    AND ip.property_id NOT IN (
+                        SELECT property_id
+                        FROM deleted_properties
+                        WHERE url_id = ? AND global_item_id = oi.global_item_id
+                    )
+                LEFT JOIN properties p 
+                    ON ip.property_id = p.id
+                LEFT JOIN item_properties name_ip 
+                    ON oi.global_item_id = name_ip.global_item_id
+                    AND name_ip.property_id = (SELECT id FROM properties WHERE name = 'name')
+                LEFT JOIN item_properties desc_ip 
+                    ON oi.global_item_id = desc_ip.global_item_id
+                    AND desc_ip.property_id = (SELECT id FROM properties WHERE name = 'description')
+                GROUP BY oi.id
+                ORDER BY oi.item_order ASC"
+            )?;
+        
+            // Change from HashMap to Vec to preserve order
+            let rows = stmt.query_map([url_id, url_id], |row| {
+                  let custom_props_json: String = row.get(4)?;
+                  let custom_properties: HashMap<String, String> = serde_json::from_str(&custom_props_json)
+                      .unwrap_or_default();
+    
+                  Ok(Item {
+                      id: row.get(0)?,
+                      name: row.get::<_, Option<String>>(2)?.unwrap_or_default(), // Handle NULL values for name
+                      description: row.get::<_, Option<String>>(3)?.unwrap_or_default(), // Handle NULL values for description
+                      wikidata_id: row.get(1)?,
+                      custom_properties,
+                  })
+            })?;
+        
+            let mut items = Vec::new();
+            for row in rows {
+                items.push(row?);
+            }
+        
+            Ok(items)
+        }
+
+        async fn get_or_create_property(
+            &self,
+            tx: &mut rusqlite::Transaction<'_>,
+            prop: &str,
+        ) -> Result<i64, Error> {
+            match tx.query_row("SELECT id FROM properties WHERE name = ?", [prop], |row| {
+                row.get::<_, i64>(0)
+            }) {
+                Ok(id) => Ok(id),
+                Err(rusqlite::Error::QueryReturnedNoRows) => {
+                    tx.execute("INSERT INTO properties (name) VALUES (?)", [prop])?;
+                    Ok(tx.last_insert_rowid())
+                }
+                Err(e) => Err(e.into()),
+            }
+        }
+
+        // Insert a new item into the database for a specific URL
+        pub async fn insert_item_by_url(&self, url: &str, item: &Item) -> Result<(), Error> {
+            log!("[DB] Starting insert for URL: {}, Item: {}", url, item.id);
+
+            // 1. Check database lock acquisition
+            let lock_start = std::time::Instant::now();
+            let mut conn = self.conn.lock().await;
+            log!("[DB] Lock acquired in {:?}", lock_start.elapsed());
+
+            // 2. Transaction handling
+            log!("[DB] Starting transaction");
+            let mut tx = conn.transaction().map_err(|e| {
+                log!("[DB] Transaction start failed: {:?}", e);
+                e
+            })?;
+
+            // 3. URL handling
+            log!("[DB] Checking URL existence: {}", url);
+            let url_id = match tx.query_row("SELECT id FROM urls WHERE url = ?", [url], |row| {
+                row.get::<_, i64>(0)
+            }) {
+                Ok(id) => {
+                    log!("[DB] Found existing URL ID: {}", id);
+                    id
+                }
+                Err(rusqlite::Error::QueryReturnedNoRows) => {
+                    log!("[DB] Inserting new URL");
+                    tx.execute("INSERT INTO urls (url) VALUES (?)", [url])?;
+                    let id = tx.last_insert_rowid();
+                    log!("[DB] Created URL ID: {}", id);
+                    id
+                }
+                Err(e) => return Err(e.into()),
+            };
+
+            // 4. Item insertion
+            let max_order: i32 = tx.query_row(
+                "SELECT COALESCE(MAX(item_order), 0) FROM items WHERE url_id = ?",
+                [url_id],
+                |row| row.get(0),
+            )?;
+
+            let global_item_id = match tx.query_row(
+                "SELECT ip.global_item_id
+                 FROM item_properties ip
+                 JOIN properties p ON ip.property_id = p.id
+                 WHERE p.name = 'name' AND ip.value = ? LIMIT 1",
+                [&item.name],
+                |row| row.get::<_, String>(0),
+            ) {
+                Ok(id) => id, // Reuse existing global_item_id
+                Err(rusqlite::Error::QueryReturnedNoRows) => {
+                    let new_id = Uuid::new_v4().to_string(); // Generate a new global_item_id
+                    new_id
+                }
+                Err(e) => return Err(e.into()),
+            };
+
+            log!("[DB] Upserting item");
+            tx.execute(
+                "INSERT INTO items (id, url_id, wikidata_id, item_order, global_item_id)
+                VALUES (?, ?, ?, ?, ?)
+                ON CONFLICT(id) DO UPDATE SET
+                    url_id = excluded.url_id,
+                    wikidata_id = excluded.wikidata_id,
+                    global_item_id = excluded.global_item_id",
+                rusqlite::params![
+                    &item.id,
+                    url_id,
+                    &item.wikidata_id,
+                    max_order + 1,
+                    &global_item_id
+                ],
+            )?;
+            log!("[DB] Item upserted successfully");
+
+            // property handling
+            let core_properties = vec![
+                ("name", &item.name),
+                ("description", &item.description)
+            ];
+
+            for (prop, value) in core_properties.into_iter().chain(
+                item.custom_properties.iter().map(|(k, v)| (k.as_str(), v))
+            ) {
+                let prop_id = self.get_or_create_property(&mut tx, prop).await?;
+                
+                tx.execute(
+                    "INSERT INTO item_properties (global_item_id, property_id, value)
+                    VALUES (?, ?, ?)
+                    ON CONFLICT(global_item_id, property_id) DO UPDATE SET
+                        value = excluded.value",
+                    rusqlite::params![&global_item_id, prop_id, value],
+                )?;
+            }
+
+            // Property synchronization
+            log!("[DB] Synchronizing properties for item {}", item.id);
+            let existing_props = {
+                let mut stmt = tx.prepare(
+                    "SELECT p.name, ip.value 
+                    FROM item_properties ip
+                    JOIN properties p ON ip.property_id = p.id
+                    WHERE ip.global_item_id = ?",
+                )?;
+            
+                let mapped_rows = stmt.query_map([&item.id], |row| {
+                    Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
+                })?;
+            
+                mapped_rows.collect::<Result<HashMap<String, String>, _>>()?
+            };
+
+            // Include core properties in current_props check
+            let mut current_props: HashSet<&str> = item.custom_properties.keys()
+                .map(|s| s.as_str())
+                .collect();
+            current_props.insert("name");
+            current_props.insert("description");
+            
+            // Cleanup with core property protection
+            for (existing_prop, _) in existing_props {
+                if !current_props.contains(existing_prop.as_str()) 
+                    && !["name", "description"].contains(&existing_prop.as_str())
+                {
+                    log!("[DB] Removing deleted property {}", existing_prop);
+                    tx.execute(
+                        "DELETE FROM item_properties 
+                        WHERE item_id = ? 
+                        AND property_id = (SELECT id FROM properties WHERE name = ?)",
+                        rusqlite::params![&item.id, existing_prop],
+                    )?;
+                }
+            }
+            tx.commit()?;
+            log!("[DB] Transaction committed successfully");
+            Ok(())
+        }
+
+        // Delete an item from the database for a specific URL
+        pub async fn delete_item_by_url(&self, url: &str, item_id: &str) -> Result<(), Error> {
+            let mut conn = self.conn.lock().await;
+            let tx = conn.transaction()?;
+
+            // Get URL ID
+            let url_id: i64 =
+                tx.query_row("SELECT id FROM urls WHERE url = ?", [url], |row| row.get(0))?;
+
+            // Delete item and properties
+            tx.execute(
+                "DELETE FROM items WHERE id = ? AND url_id = ?",
+                [item_id, &url_id.to_string()],
+            )?;
+        
+            tx.execute(
+                "DELETE FROM item_properties WHERE global_item_id = ?",
+                [item_id],
+            )?;
+
+            tx.commit()?;
+            Ok(())
+        }
+
+        // Delete a property from the database for a specific URL
+        pub async fn delete_property_by_url(&self, url: &str, property: &str) -> Result<(), Error> {
+            let mut conn = self.conn.lock().await;
+            let tx = conn.transaction()?;
+        
+            // Get URL ID
+            let url_id: i64 =
+                tx.query_row("SELECT id FROM urls WHERE url = ?", [url], |row| row.get(0))?;
+        
+            // Get property ID
+            let property_id: i64 = tx.query_row(
+                "SELECT id FROM properties WHERE name = ?",
+                [property],
+                |row| row.get(0),
+            )?;
+        
+            // Get all global_item_ids for this URL
+            {
+                let mut stmt = tx.prepare("SELECT global_item_id FROM items WHERE url_id = ?")?;
+                let global_item_ids: Vec<String> = stmt
+                    .query_map([url_id], |row| row.get(0))?
+                    .collect::<Result<_, _>>()?;
+        
+                // Insert into deleted_properties for each global_item_id
+                for global_item_id in global_item_ids {
+                    tx.execute(
+                        "INSERT OR IGNORE INTO deleted_properties (url_id, global_item_id, property_id)
+                        VALUES (?, ?, ?)",
+                        rusqlite::params![url_id, global_item_id, property_id],
+                    )?;
+                }
+            }
+        
+            tx.commit()?;
+            Ok(())
+        }
+
+        pub async fn add_selected_property(&self, url: &str, property: &str) -> Result<(), Error> {
+            let mut conn = self.conn.lock().await;
+            let tx = conn.transaction()?;
+
+            // Insert URL if it does not exists
+            tx.execute("INSERT OR IGNORE INTO urls (url) VALUES (?)", [url])?;
+
+            // Get URL ID
+            let url_id = tx.query_row("SELECT id FROM urls WHERE url = ?", [url], |row| {
+                row.get::<_, i64>(0)
+            })?;
+
+            // Get/Create property
+            let prop_id = match tx.query_row(
+                "SELECT id FROM properties WHERE name = ?",
+                [property],
+                |row| row.get::<_, i64>(0),
+            ) {
+                Ok(id) => id,
+                Err(_) => {
+                    tx.execute("INSERT INTO properties (name) VALUES (?)", [property])?;
+                    tx.last_insert_rowid()
+                }
+            };
+
+            // Insert into selected_properties
+            tx.execute(
+                "INSERT OR IGNORE INTO selected_properties (url_id, property_id) VALUES (?, ?)",
+                [url_id, prop_id],
+            )?;
+
+            tx.commit()?;
+            Ok(())
+        }
+
+        pub async fn get_selected_properties(&self, url: &str) -> Result<Vec<String>, Error> {
+            let conn = self.conn.lock().await;
+            let mut stmt = conn.prepare(
+                "SELECT p.name 
+                 FROM selected_properties sp
+                 JOIN properties p ON sp.property_id = p.id
+                 JOIN urls u ON sp.url_id = u.id
+                 WHERE u.url = ?",
+            )?;
+
+            let properties = stmt.query_map([url], |row| row.get(0))?;
+            properties.collect()
+        }
+
+        // function to log database state
+        pub async fn debug_dump(&self) -> Result<(), Error> {
+            let conn = self.conn.lock().await;
+            log!("[DATABASE DEBUG] URLs:");
+            let mut stmt = conn.prepare("SELECT id, url FROM urls")?;
+            let urls = stmt.query_map([], |row| {
+                Ok(format!(
+                    "ID: {}, URL: {}",
+                    row.get::<_, i64>(0)?,
+                    row.get::<_, String>(1)?
+                ))
+            })?;
+            for url in urls {
+                log!("[DATABASE DEBUG] {}", url?);
+            }
+
+            log!("[DATABASE DEBUG] Items:");
+            let mut stmt = conn.prepare("SELECT id, name FROM items")?;
+            let items = stmt.query_map([], |row| {
+                Ok(format!(
+                    "ID: {}, Name: '{}'",
+                    row.get::<_, String>(0)?,
+                    row.get::<_, String>(1)?
+                ))
+            })?;
+            for item in items {
+                log!("[DATABASE DEBUG] {}", item?);
+            }
+
+            Ok(())
+        }
+    }
+
+    // Define a struct to represent an item in the database
+    #[derive(Debug, Deserialize, Serialize, Clone)]
+    pub struct DbItem {
+        pub id: String,
+        pub name: String,
+        pub description: String,
+        pub wikidata_id: Option<String>,
+    }
+}
+
+#[cfg(feature = "ssr")]
+pub use db_impl::{Database, DbItem};

src/lib.rs

@@ -2,6 +2,9 @@ pub mod app;
 pub mod components;
 pub mod models;
 pub mod nostr;
+pub mod api;
+#[cfg(feature = "ssr")]
+pub mod db;
 
 
 #[cfg(feature = "hydrate")]

src/main.rs

@@ -1,4 +1,11 @@
 #[cfg(feature = "ssr")]
+use actix_web::{web, HttpResponse, Responder};
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use compareware::db::Database;
+use compareware::api::{ItemRequest,create_item, get_items, get_selected_properties, add_selected_property};
+use compareware::models::item::Item;
+
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
     use actix_files::Files;
@@ -6,33 +13,131 @@ async fn main() -> std::io::Result<()> {
     use leptos::*;
     use leptos_actix::{generate_route_list, LeptosRoutes};
     use compareware::app::*;
-
+    use compareware::db::Database;
+    use compareware::api::{delete_item, delete_property}; // Import API handlers
+    use std::sync::Arc;
+    use tokio::sync::Mutex;
+    
+    // Initialize the database
+    let db = Database::new("compareware.db").unwrap();
+    db.create_schema().await.unwrap(); // Ensure the schema is created
+    let db = Arc::new(Mutex::new(db)); // Wrap the database in an Arc<Mutex<T>> for shared state
+    println!("Schema created successfully!");
+    
+    // Load configuration
     let conf = get_configuration(None).await.unwrap();
     let addr = conf.leptos_options.site_addr;
+
+
     // Generate the list of routes in your Leptos App
     let routes = generate_route_list(App);
     println!("listening on http://{}", &addr);
 
+    // Start the Actix Web server
     HttpServer::new(move || {
         let leptos_options = &conf.leptos_options;
         let site_root = &leptos_options.site_root;
+        let db = db.clone(); // Clone the Arc for each worker
+
 
         App::new()
-            // serve JS/WASM/CSS from `pkg`
+            .app_data(web::Data::new(db.clone()))
+            // Register custom API routes BEFORE Leptos server functions
+            .service(
+                web::scope("/api")
+                .service(
+                    web::scope("/urls/{url}")
+                        .route("/items", web::get().to(get_items_handler)) // GET items by URL
+                        .route("/items", web::post().to(create_item_handler)) // Create item for URL
+                        .route("/items/{item_id}", web::delete().to(delete_item)) // Delete item for URL
+                        .route("/properties", web::get().to(get_selected_properties_handler))
+                        .route("/properties", web::post().to(add_selected_property_handler))
+                        .route("/properties/{property}", web::delete().to(delete_property)) // Delete property for URL
+                )
+            )
+            // Register server functions
+            .route("/api/{tail:.*}", leptos_actix::handle_server_fns())
+            // Serve JS/WASM/CSS from `pkg`
             .service(Files::new("/pkg", format!("{site_root}/pkg")))
-            // serve other assets from the `assets` directory
+            // Serve other assets from the `assets` directory
             .service(Files::new("/assets", site_root))
-            // serve the favicon from /favicon.ico
+            // Serve the favicon from /favicon.ico
             .service(favicon)
+            // Register Leptos routes
             .leptos_routes(leptos_options.to_owned(), routes.to_owned(), App)
+            // Pass Leptos options to the app
             .app_data(web::Data::new(leptos_options.to_owned()))
-        //.wrap(middleware::Compress::default())
+            //.wrap(middleware::Compress::default())
+            // Pass the database as shared state
+            .app_data(web::Data::new(db))
+            // Register URL routing
+            .service(web::resource("/").route(web::get().to(index)))
+            .service(web::resource("/{url}").route(web::get().to(url_handler)))
     })
     .bind(&addr)?
     .run()
     .await
 }
 
+// Handler to get items for a specific URL
+async fn get_items_handler(
+    db: web::Data<Arc<Mutex<Database>>>,
+    url: web::Path<String>,
+) -> impl Responder {
+    get_items(db, web::Query(url.into_inner())).await
+}
+
+// Handler to create an item for a specific URL
+async fn create_item_handler(
+    db: web::Data<Arc<Mutex<Database>>>,
+    url: web::Path<String>,
+    item: web::Json<Item>,
+) -> impl Responder {
+    let request = ItemRequest { 
+        url: url.into_inner(),
+        item: item.into_inner() 
+    };
+    create_item(db, web::Json(request)).await
+}
+
+// // Handler to delete an item for a specific URL
+// async fn delete_item_handler(
+//     db: web::Data<Arc<Mutex<Database>>>,
+//     path: web::Path<(String, String)>,
+// ) -> impl Responder {
+//     let (url, item_id) = path.into_inner();
+//     delete_item_by_url(db, web::Path::from(url), web::Path::from(item_id)).await
+// }
+
+#[cfg(feature = "ssr")]
+async fn get_selected_properties_handler(
+    db: web::Data<Arc<Mutex<Database>>>,
+    url: web::Path<String>,
+) -> impl Responder {
+    get_selected_properties(db, url).await
+}
+
+#[cfg(feature = "ssr")]
+async fn add_selected_property_handler(
+    db: web::Data<Arc<Mutex<Database>>>,
+    url: web::Path<String>,
+    property: web::Json<String>,
+) -> impl Responder {
+    add_selected_property(db, url, property).await
+}
+#[cfg(feature = "ssr")]
+// Define the index handler
+async fn index() -> HttpResponse {
+    HttpResponse::Ok().body("Welcome to CompareWare!")
+}
+#[cfg(feature = "ssr")]
+// Define the URL handler
+async fn url_handler(url: web::Path<String>) -> HttpResponse {
+    let url = url.into_inner();
+    // TO DO: Implement URL-based content storage and editing functionality
+    HttpResponse::Ok().body(format!("You are viewing the content at {}", url))
+}
+
 #[cfg(feature = "ssr")]
 #[actix_web::get("favicon.ico")]
 async fn favicon(
@@ -63,4 +168,4 @@ pub fn main() {
     console_error_panic_hook::set_once();
 
     leptos::mount_to_body(App);
-}
+}

src/models/item.rs

@@ -1,19 +1,12 @@
 /// Represents an Item in CompareWare.
 /// Each item has metadata and key-value tags for categorization.
 use serde::{Deserialize, Serialize};
-
+use std::collections::HashMap;
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Item {
     pub id: String,
     pub name: String,
     pub description: String,
-    pub tags: Vec<(String, String)>,
-    pub reviews: Vec<ReviewWithRating>,
     pub wikidata_id: Option<String>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ReviewWithRating {
-    pub content: String,
-    pub rating: u8, // Ratings from 1 to 5
+    pub custom_properties: HashMap<String, String>,
 }