Enhance README and API functionality with new endpoints and error handling; add package.json and package-lock.json for Node.js testing

.gitignore

@@ -0,0 +1,3 @@
+/venv
+
+/node_modules

README.md

@@ -1,10 +1,156 @@
----
-title: SqlLIte
-emoji: 🦀
-colorFrom: gray
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# SQLite Server on HF Spaces
+
+A persistent SQLite database server running on Hugging Face Spaces with FastAPI wrapper.
+
+## Features
+
+✅ **Persistent Storage** - Data stored in `/data/sqlite.db` (survives restarts)
+✅ **REST API** - Full SQLite CRUD operations via HTTP
+✅ **Dual Services** - SQLite server (port 8000) + FastAPI wrapper (port 7860)
+✅ **Schema Management** - Query schema and list tables
+✅ **HF Spaces Ready** - Docker setup for Hugging Face deployment
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────┐
+│         HF Spaces Container                 │
+├─────────────────────────────────────────────┤
+│  Port 7860 (exposed)                        │
+│  ├── FastAPI Wrapper (app.py)               │
+│  │   └── Proxies to SQLite Server           │
+│  │                                          │
+│  Port 8000 (internal)                       │
+│  └── SQLite Server (sqlite_server.py)       │
+│      └── /data/sqlite.db (persistent)       │
+└─────────────────────────────────────────────┘
+```
+
+## API Endpoints
+
+### Health Check
+```bash
+GET /health
+GET /api/v1/heartbeat
+```
+
+### Query Data (SELECT)
+```bash
+POST /api/v1/query
+Content-Type: application/json
+
+{
+  "sql": "SELECT * FROM users"
+}
+```
+
+### Execute (INSERT/UPDATE/DELETE)
+```bash
+POST /api/v1/execute
+Content-Type: application/json
+
+{
+  "sql": "INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')"
+}
+```
+
+### Schema & Tables
+```bash
+GET /api/v1/tables
+GET /api/v1/schema
+```
+
+## Deployment to HF Spaces
+
+1. **Create a new Space:**
+   - Go to https://huggingface.co/new-space
+   - Select "Docker" as SDK
+   - Upload/push this repo
+
+2. **Files needed:**
+   - `Dockerfile` - Container setup
+   - `start.sh` - Startup script
+   - `app.py` - FastAPI wrapper
+   - `sqlite_server.py` - SQLite API server
+   - `requirements.txt` - Python dependencies
+
+3. **Persistent Storage:**
+   - HF Spaces automatically mounts `/data` as persistent volume
+   - SQLite database is stored at `/data/sqlite.db`
+   - Data persists across Space restarts
+
+## Local Testing
+
+```bash
+# Install dependencies
+npm install
+pip install -r requirements.txt
+
+# Start the servers
+source venv/bin/activate
+python3 sqlite_server.py &  # Port 8000
+python3 app.py &             # Port 7860
+
+# Run tests
+npm run test
+```
+
+## File Structure
+
+```
+.
+├── app.py                 # FastAPI wrapper (port 7860)
+├── sqlite_server.py       # SQLite API server (port 8000)
+├── start.sh              # Startup script
+├── Dockerfile            # Container configuration
+├── requirements.txt      # Python dependencies
+├── package.json         # Node.js test config
+├── test.js              # Test suite
+└── README.md            # This file
+```
+
+## Example Usage
+
+### Create a table
+```bash
+curl -X POST https://your-space.hf.space/api/v1/execute \
+  -H "Content-Type: application/json" \
+  -d '{
+    "sql": "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)"
+  }'
+```
+
+### Insert data
+```bash
+curl -X POST https://your-space.hf.space/api/v1/execute \
+  -H "Content-Type: application/json" \
+  -d '{
+    "sql": "INSERT INTO users (name, email) VALUES ('"'"'Alice'"'"', '"'"'alice@example.com'"'"')"
+  }'
+```
+
+### Query data
+```bash
+curl -X POST https://your-space.hf.space/api/v1/query \
+  -H "Content-Type: application/json" \
+  -d '{"sql": "SELECT * FROM users"}'
+```
+
+## Troubleshooting
+
+**Health check fails:**
+- Ensure SQLite server started before FastAPI wrapper
+- Check `start.sh` sleep duration (currently 2 seconds)
+
+**Port conflicts:**
+- SQLite server: port 8000 (internal)
+- FastAPI wrapper: port 7860 (exposed on HF Spaces)
+
+**Data not persisting:**
+- Verify `/data` directory exists
+- Check HF Spaces has persistent storage enabled
+- Database file should be at `/data/sqlite.db`
+
+## Credits
+
+Pattern based on ChromaDB HF Spaces deployment.

app.py

@@ -1,12 +1,19 @@
 import os
 import requests
-from fastapi import FastAPI
-from fastapi.responses import HTMLResponse
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import HTMLResponse, JSONResponse
+from pydantic import BaseModel
 
 app = FastAPI(title="SQLite on HF Space")
 
 SQLITE_URL = "http://localhost:8000"
 
+class QueryRequest(BaseModel):
+    sql: str
+
+class ExecuteRequest(BaseModel):
+    sql: str
+
 @app.get("/", response_class=HTMLResponse)
 def read_root():
     return """
@@ -14,32 +21,81 @@ def read_root():
         <head><title>SQLite HF Space</title></head>
         <body>
             <h1>✅ SQLite Server is Running!</h1>
-            <p>Persistent Storage: /data/sqlite.db</p>
-            <p>API Endpoint: <a href="/docs">Swagger UI</a></p>
-            <p>Direct SQLite API: <code>{}/api/v1/heartbeat</code></p>
-            <p><strong>Available Endpoints:</strong></p>
+            <p><strong>Persistent Storage:</strong> /data/sqlite.db</p>
+            <p><strong>API Documentation:</strong> <a href="/docs">Swagger UI</a></p>
+            <hr>
+            <h3>Available Endpoints:</h3>
             <ul>
-                <li>GET /api/v1/heartbeat - Health check</li>
-                <li>POST /api/v1/query - Execute SELECT queries</li>
-                <li>POST /api/v1/execute - Execute INSERT/UPDATE/DELETE</li>
-                <li>GET /api/v1/tables - List all tables</li>
-                <li>GET /api/v1/schema - Get database schema</li>
+                <li><code>GET /api/v1/heartbeat</code> - Health check</li>
+                <li><code>POST /api/v1/query</code> - Execute SELECT queries</li>
+                <li><code>POST /api/v1/execute</code> - Execute INSERT/UPDATE/DELETE</li>
+                <li><code>GET /api/v1/tables</code> - List all tables</li>
+                <li><code>GET /api/v1/schema</code> - Get database schema</li>
             </ul>
         </body>
     </html>
-    """.format(SQLITE_URL)
+    """
 
 @app.get("/health")
 def health_check():
     try:
-        response = requests.get(f"{SQLITE_URL}/api/v1/heartbeat")
+        response = requests.get(f"{SQLITE_URL}/api/v1/heartbeat", timeout=5)
         if response.status_code == 200:
             return {"status": "healthy", "sqlite": "up"}
         else:
-            return {"status": "unhealthy", "sqlite": "error"}
+            return {"status": "unhealthy", "detail": response.text}
     except Exception as e:
         return {"status": "error", "detail": str(e)}
 
+@app.get("/api/v1/heartbeat")
+def heartbeat():
+    try:
+        response = requests.get(f"{SQLITE_URL}/api/v1/heartbeat", timeout=5)
+        return response.json()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"SQLite server error: {str(e)}")
+
+@app.post("/api/v1/query")
+def query(request: QueryRequest):
+    try:
+        response = requests.post(f"{SQLITE_URL}/api/v1/query", json={"sql": request.sql}, timeout=10)
+        if response.status_code != 200:
+            raise HTTPException(status_code=response.status_code, detail=response.text)
+        return response.json()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Query error: {str(e)}")
+
+@app.post("/api/v1/execute")
+def execute(request: ExecuteRequest):
+    try:
+        response = requests.post(f"{SQLITE_URL}/api/v1/execute", json={"sql": request.sql}, timeout=10)
+        if response.status_code != 200:
+            raise HTTPException(status_code=response.status_code, detail=response.text)
+        return response.json()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Execute error: {str(e)}")
+
+@app.get("/api/v1/tables")
+def list_tables():
+    try:
+        response = requests.get(f"{SQLITE_URL}/api/v1/tables", timeout=5)
+        if response.status_code != 200:
+            raise HTTPException(status_code=response.status_code, detail=response.text)
+        return response.json()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Tables error: {str(e)}")
+
+@app.get("/api/v1/schema")
+def get_schema():
+    try:
+        response = requests.get(f"{SQLITE_URL}/api/v1/schema", timeout=5)
+        if response.status_code != 200:
+            raise HTTPException(status_code=response.status_code, detail=response.text)
+        return response.json()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Schema error: {str(e)}")
+
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("PORT", 7860)))
+    port = int(os.getenv("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

package-lock.json

@@ -0,0 +1,106 @@
+{
+  "name": "sqlite-server-tester",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "sqlite-server-tester",
+      "version": "1.0.0",
+      "dependencies": {
+        "node-fetch": "^3.3.0"
+      }
+    },
+    "node_modules/data-uri-to-buffer": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
+      "integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/fetch-blob": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
+      "integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "paypal",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "node-domexception": "^1.0.0",
+        "web-streams-polyfill": "^3.0.3"
+      },
+      "engines": {
+        "node": "^12.20 || >= 14.13"
+      }
+    },
+    "node_modules/formdata-polyfill": {
+      "version": "4.0.10",
+      "resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
+      "integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
+      "license": "MIT",
+      "dependencies": {
+        "fetch-blob": "^3.1.2"
+      },
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
+    "node_modules/node-domexception": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
+      "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==",
+      "deprecated": "Use your platform's native DOMException instead",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "github",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.5.0"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
+      "integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
+      "license": "MIT",
+      "dependencies": {
+        "data-uri-to-buffer": "^4.0.0",
+        "fetch-blob": "^3.1.4",
+        "formdata-polyfill": "^4.0.10"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/node-fetch"
+      }
+    },
+    "node_modules/web-streams-polyfill": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
+      "integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    }
+  }
+}

package.json

@@ -0,0 +1,14 @@
+{
+  "name": "sqlite-server-tester",
+  "version": "1.0.0",
+  "description": "Test suite for SQLite Server",
+  "main": "test.js",
+  "type": "module",
+  "scripts": {
+    "test": "node test.js",
+    "dev": "node test.js"
+  },
+  "dependencies": {
+    "node-fetch": "^3.3.0"
+  }
+}

test.js

@@ -0,0 +1,226 @@
+const fetch = (...args) =>
+  import("node-fetch").then(({ default: fetch }) => fetch(...args));
+
+// ============ CONFIG ============
+// Change BASE_URL to your hosted server
+const BASE_URL = "https://maxxcarl-sqllite.hf.space";
+// For local testing, use: "http://localhost:7860"
+
+// ============ COLORS FOR CONSOLE ============
+const colors = {
+  reset: "\x1b[0m",
+  bright: "\x1b[1m",
+  green: "\x1b[32m",
+  blue: "\x1b[34m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  cyan: "\x1b[36m",
+};
+
+function log(msg, color = "reset") {
+  console.log(`${colors[color]}${msg}${colors.reset}`);
+}
+
+function header(msg) {
+  log(`\n${"=".repeat(60)}`, "cyan");
+  log(`  ${msg}`, "bright");
+  log(`${"=".repeat(60)}\n`, "cyan");
+}
+
+// ============ API FUNCTIONS ============
+async function apiCall(endpoint, method = "GET", body = null) {
+  const url = `${BASE_URL}${endpoint}`;
+  const options = {
+    method,
+    headers: { "Content-Type": "application/json" },
+  };
+
+  if (body) options.body = JSON.stringify(body);
+
+  const response = await fetch(url, options);
+  const data = await response.json();
+
+  if (!response.ok) {
+    throw new Error(data.detail || `API Error: ${response.status}`);
+  }
+
+  return data;
+}
+
+async function executeQuery(sql) {
+  return apiCall("/api/v1/query", "POST", { sql });
+}
+
+async function executeUpdate(sql) {
+  return apiCall("/api/v1/execute", "POST", { sql });
+}
+
+async function getTables() {
+  return apiCall("/api/v1/tables");
+}
+
+async function getSchema() {
+  return apiCall("/api/v1/schema");
+}
+
+async function healthCheck() {
+  return apiCall("/api/v1/heartbeat");
+}
+
+// ============ MAIN TEST FLOW ============
+async function main() {
+  try {
+    log(`\n🚀 SQLite Server Tester`, "bright");
+    log(`Base URL: ${BASE_URL}`, "yellow");
+    log(`All endpoints accessed through: ${BASE_URL}\n`, "yellow");
+
+    // 1. Health Check
+    header("1️⃣  HEALTH CHECK");
+    try {
+      const health = await healthCheck();
+      log(`✅ Server is healthy!`, "green");
+      log(`Response: ${JSON.stringify(health, null, 2)}\n`, "cyan");
+    } catch (e) {
+      log(`❌ Server health check failed: ${e.message}`, "red");
+      return;
+    }
+
+    // 2. Create Users Table
+    header("2️⃣  CREATE USERS TABLE");
+    const createUsersSQL = `
+      CREATE TABLE IF NOT EXISTS users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        email TEXT NOT NULL UNIQUE,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+    try {
+      await executeUpdate(createUsersSQL);
+      log(`✅ Users table created!`, "green");
+    } catch (e) {
+      log(`❌ Error creating users table: ${e.message}`, "red");
+    }
+
+    // 3. Create Products Table
+    header("3️⃣  CREATE PRODUCTS TABLE");
+    const createProductsSQL = `
+      CREATE TABLE IF NOT EXISTS products (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        price REAL NOT NULL,
+        stock INTEGER DEFAULT 0,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+    try {
+      await executeUpdate(createProductsSQL);
+      log(`✅ Products table created!`, "green");
+    } catch (e) {
+      log(`❌ Error creating products table: ${e.message}`, "red");
+    }
+
+    // 4. Insert Users
+    header("4️⃣  INSERT USERS");
+    const usersData = [
+      { name: "Alice Johnson", email: "alice@example.com" },
+      { name: "Bob Smith", email: "bob@example.com" },
+      { name: "Charlie Brown", email: "charlie@example.com" },
+    ];
+
+    for (const user of usersData) {
+      const insertSQL = `INSERT INTO users (name, email) VALUES ('${user.name}', '${user.email}')`;
+      try {
+        await executeUpdate(insertSQL);
+        log(`  ✅ Added: ${user.name}`, "green");
+      } catch (e) {
+        log(`  ⚠️  ${user.name}: ${e.message}`, "yellow");
+      }
+    }
+
+    // 5. Insert Products
+    header("5️⃣  INSERT PRODUCTS");
+    const productsData = [
+      { name: "Laptop Pro", price: 1299.99, stock: 15 },
+      { name: "Wireless Mouse", price: 29.99, stock: 100 },
+      { name: "USB-C Cable", price: 9.99, stock: 250 },
+      { name: "Monitor 4K", price: 499.99, stock: 8 },
+    ];
+
+    for (const product of productsData) {
+      const insertSQL = `INSERT INTO products (name, price, stock) VALUES ('${product.name}', ${product.price}, ${product.stock})`;
+      try {
+        await executeUpdate(insertSQL);
+        log(`  ✅ Added: ${product.name}`, "green");
+      } catch (e) {
+        log(`  ⚠️  ${product.name}: ${e.message}`, "yellow");
+      }
+    }
+
+    // 6. Get All Tables
+    header("6️⃣  LIST ALL TABLES");
+    try {
+      const tables = await getTables();
+      log(`Found tables: ${tables.tables.join(", ")}`, "cyan");
+    } catch (e) {
+      log(`❌ Error getting tables: ${e.message}`, "red");
+    }
+
+    // 7. Get Schema
+    header("7️⃣  DATABASE SCHEMA");
+    try {
+      const schema = await getSchema();
+      log(JSON.stringify(schema, null, 2), "cyan");
+    } catch (e) {
+      log(`❌ Error getting schema: ${e.message}`, "red");
+    }
+
+    // 8. Query Users
+    header("8️⃣  QUERY USERS");
+    try {
+      const result = await executeQuery("SELECT * FROM users");
+      log(JSON.stringify(result.data, null, 2), "cyan");
+    } catch (e) {
+      log(`❌ Error querying users: ${e.message}`, "red");
+    }
+
+    // 9. Query Products with Price > 50
+    header("9️⃣  QUERY EXPENSIVE PRODUCTS (> $50)");
+    try {
+      const result = await executeQuery(
+        "SELECT * FROM products WHERE price > 50 ORDER BY price DESC",
+      );
+      log(JSON.stringify(result.data, null, 2), "cyan");
+    } catch (e) {
+      log(`❌ Error querying products: ${e.message}`, "red");
+    }
+
+    // 10. Summary
+    header("✅ ALL TESTS COMPLETED");
+    log(
+      `
+    🎉 Database Setup Complete!
+
+    Tables Created:
+    - users (name, email, created_at)
+    - products (name, price, stock, created_at)
+
+    Sample Data:
+    - 3 users inserted
+    - 4 products inserted
+
+    Access your data:
+    - API: ${BASE_URL}
+    - Swagger UI: ${BASE_URL}/docs
+    - Health: ${BASE_URL}/health
+    `,
+      "green",
+    );
+  } catch (error) {
+    log(`\n❌ Fatal Error: ${error.message}`, "red");
+    process.exit(1);
+  }
+}
+
+// Run the tests
+main().catch(console.error);