udsl-sdk 1.0.5 → 1.0.6

package/README.md

@@ -1,213 +1,243 @@
 # UDSL SDK
 
-Crash-Safe Data Recovery SDK for JavaScript and TypeScript applications.
+Crash-Safe Data Recovery SDK using Write-Ahead Logging (WAL), Snapshots, Multi-Tenant Isolation, and Instant Recovery.
 
-UDSL (Universal Data Safety Layer) helps applications prevent data loss by using Write-Ahead Logging (WAL), Snapshots, Recovery, Version History, and Rollback mechanisms.
+## What is UDSL?
 
-## Why UDSL?
-
-Applications can lose user data because of:
+UDSL (Universal Data Safety Layer) helps applications prevent data loss caused by:
 
 * Application crashes
 * Power failures
-* Unexpected shutdowns
-* Network interruptions
-* Software bugs
+* System shutdowns
+* Unexpected errors
+* Process termination
 
-UDSL provides a recovery layer that ensures user data can be restored even after failures.
+Instead of storing data directly, applications write through UDSL, which maintains a Write-Ahead Log (WAL) and snapshots to ensure recoverability.
 
 ---
 
 ## Features
 
 * Write-Ahead Logging (WAL)
-* Snapshot-based recovery
-* Crash recovery
-* Version history
-* Rollback support
-* Multi-tenant architecture
-* API key authentication
-* Offline-first support
-* TypeScript support
+* Instant Recovery Engine
+* Snapshot-Based Recovery
+* Multi-Tenant Isolation
+* API Key Authentication
+* Docker Deployment
+* NPM SDK
+* Version History
+* Rollback Support
+* Self-Hosted Infrastructure
 
 ---
 
 ## Installation
 
+Install the SDK:
+
 ```bash
 npm install udsl-sdk
 ```
 
+Start the recovery server:
+
+```bash
+npx udsl-sdk start
+```
+
+Expected output:
+
+```text
+🚀 Starting UDSL...
+📦 Pulling UDSL image...
+🔥 Starting server...
+✅ UDSL running at http://localhost:3001
+```
+
 ---
 
-## Initialization
+## Quick Start
+
+### Initialize SDK
 
-```typescript
-import { UDSL } from "udsl-sdk";
+```javascript
+const { UDSL } = require("udsl-sdk");
 
 UDSL.init({
   baseUrl: "http://localhost:3001",
-  apiKey: "your-api-key"
+  apiKey: "test-key-123"
 });
 ```
 
----
-
-## Save Data
+### Save Data
 
-```typescript
-await UDSL.save("doc1", {
-  title: "Project Notes",
-  content: "Building a crash-safe recovery system"
+```javascript
+await UDSL.save("project1", {
+  name: "My Project",
+  progress: 50
 });
 ```
 
----
-
-## Read Data
+### Recover Data
 
-```typescript
-const data = await UDSL.get("doc1");
+```javascript
+const data = await UDSL.get("project1");
 
 console.log(data);
 ```
 
----
-
-## View History
-
-```typescript
-const history = await UDSL.history("doc1");
-
-console.log(history);
+Output:
+
+```javascript
+{
+  key: "companyA:project1",
+  state: {
+    name: "My Project",
+    progress: 50
+  },
+  eventsCount: 1,
+  mode: "INSTANT_RECOVERY"
+}
 ```
 
 ---
 
-## Rollback
+## Multi-Tenant Architecture
 
-```typescript
-await UDSL.rollback("doc1", 1);
-```
-
-This restores the document to version 1.
-
----
+UDSL automatically isolates data by tenant.
 
-## How It Works
+Example:
 
-### Step 1
+```json
+{
+  "test-key-123": {
+    "tenantId": "companyA"
+  },
+  "test-key-456": {
+    "tenantId": "companyB"
+  }
+}
+```
 
-Application writes data.
+Data written by Company A:
 
 ```text
-Application
-     ↓
-UDSL SDK
+companyA:project1
 ```
 
-### Step 2
-
-SDK sends data to the recovery engine.
+Data written by Company B:
 
 ```text
-SDK
- ↓
-Recovery Server
+companyB:project1
 ```
 
-### Step 3
-
-Server writes to WAL before acknowledging.
+Each tenant can only access its own data.
 
-```text
-Request
-  ↓
-WAL
-  ↓
-Snapshot
-```
+---
 
-### Step 4
+## Crash Recovery Example
 
-If a crash occurs, recovery rebuilds the latest state.
+Save data:
 
-```text
-Snapshot
-    +
-WAL Replay
-    ↓
-Recovered State
+```javascript
+await UDSL.save("document1", {
+  text: "Important content"
+});
 ```
 
----
-
-## Architecture
+Stop server:
 
-```text
-Application
-    ↓
-UDSL SDK
-    ↓
-Recovery API
-    ↓
-WAL
-Snapshot
-History
-Rollback
+```bash
+docker stop udsl-server
 ```
 
----
+Start again:
 
-## Example Use Cases
+```bash
+npx udsl-sdk start
+```
 
-### Notes Applications
+Recover:
 
-Recover user notes after crashes.
+```javascript
+const data = await UDSL.get("document1");
+```
 
-### Form Builders
+Your data is restored from WAL and snapshots.
 
-Prevent loss of partially completed forms.
+---
 
-### Code Editors
+## API
 
-Restore unsaved work automatically.
+### UDSL.init()
 
-### Enterprise Applications
+```javascript
+UDSL.init({
+  baseUrl: string,
+  apiKey: string
+});
+```
 
-Maintain audit trails and recovery history.
+### UDSL.save()
 
-### SaaS Platforms
+```javascript
+await UDSL.save(key, value);
+```
 
-Provide reliable data recovery for customers.
+### UDSL.get()
+
+```javascript
+const data = await UDSL.get(key);
+```
 
 ---
 
-## Security
+## Docker
 
-* API Key Authentication
-* Tenant Isolation
-* Crash-Safe Writes
-* Recovery Validation
+UDSL Server runs inside Docker.
+
+Manual start:
+
+```bash
+docker run -d -p 3001:3001 omghadage/udsl-server:latest
+```
 
 ---
 
-## Roadmap
+## Architecture
 
-* Local Offline Queue
-* Background Sync Engine
-* Data Encryption
-* Cloud Dashboard
-* Analytics
-* Mobile SDK
-* React SDK
-* Automatic Backup System
+```text
+Application
+      │
+      ▼
+   UDSL SDK
+      │
+      ▼
+ UDSL Server
+      │
+      ▼
+ Write-Ahead Log
+      │
+      ▼
+ Snapshot Store
+      │
+      ▼
+ Recovery Engine
+```
 
 ---
 
-## License
+## Use Cases
 
-MIT License
+* Note-taking applications
+* Project management software
+* IDEs and code editors
+* CAD tools
+* Form builders
+* Offline-first applications
+* Enterprise systems
+
+Any application where user data must survive crashes.
 
 ---
 
@@ -215,4 +245,6 @@ MIT License
 
 Om Ghadage
 
-Building reliable systems that help applications recover data after failures.
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "udsl-sdk",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Crash-safe data recovery SDK (WAL + Snapshot based)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",