jotdb 0.1.4 → 0.1.5

package/README.md

@@ -1,203 +1,78 @@
 # JotDB
 
-## 🚀 Quick Start: Using JotDB in Your Cloudflare Worker
+A lightweight, schema-less database built on Cloudflare Durable Objects. Perfect for quick prototyping and applications that need simple data storage without the complexity of traditional databases.
 
-### 1. **Install JotDB**
+## Why JotDB?
 
-```bash
-bun add jotdb
-# or
-npm install jotdb
-```
-
-### 2. **Bind the Durable Object in your wrangler.toml or wrangler.json**
-
-```toml
-[[durable_objects.bindings]]
-name = "JOTDB"
-class_name = "JotDB"
-```
-
-### 3. **Register the Durable Object in your Worker**
-
-```ts
-import { JotDB } from 'jotdb';
-
-export interface Env {
-  JOTDB: DurableObjectNamespace<JotDB>;
-}
-
-export default {
-  async fetch(request: Request, env: Env) {
-    // Get a stub for your JotDB instance
-    const id = env.JOTDB.idFromName("my-db");
-    const db = env.JOTDB.get(id);
-
-    // Use RPC (recommended, requires extends DurableObject)
-    await db.set("key", "value");
-    const value = await db.get("key");
-
-    return new Response(`Value: ${value}`);
-  }
-};
-```
-
-### 4. **Deploy or run locally**
-
-```bash
-wrangler dev
-# or
-wrangler deploy
-```
-
----
-
-## 📝 Notes
-
-- **RPC support:** JotDB uses Cloudflare's new JavaScript-native RPC. You can call methods directly on the stub (e.g., `db.set(...)`, `db.get(...)`).
-- **No fetch needed:** You do not need to use HTTP fetch to communicate with your Durable Object—just call methods!
-- **TypeScript:** Use `DurableObjectNamespace<JotDB>` for full type safety.
-- **See the API section below for all available methods.**
-
----
+I needed a quick way to save data without dealing with schemas, SQL, or complex database setup. While Firestore is great, it can be overkill for simple use cases. JotDB provides a simpler alternative by leveraging Cloudflare Durable Objects, making it perfect for:
 
-## 📚 Full Example
-
-```ts
-import { JotDB } from 'jotdb';
-
-export interface Env {
-  JOTDB: DurableObjectNamespace<JotDB>;
-}
-
-export default {
-  async fetch(request: Request, env: Env) {
-    const id = env.JOTDB.idFromName("my-db");
-    const db = env.JOTDB.get(id);
-
-    await db.setSchema({
-      name: "string",
-      age: "number",
-      email: "email"
-    });
-
-    await db.setAll({
-      name: "Alice",
-      age: 42,
-      email: "alice@example.com"
-    });
-
-    const all = await db.getAll();
-
-    return new Response(JSON.stringify(all, null, 2), {
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-};
-```
-
----
-
-A lightweight, schema-validated key-value store built on Cloudflare Durable Objects.
-
-## Features
-
-- Schema validation using Zod
-- Automatic schema inference
-- Audit logging
-- TypeScript support
-- Read-only mode
-- Auto-strip mode for schema validation
+- Quick prototypes
+- Small to medium applications
+- Serverless environments
+- Real-time data storage
+- Collaborative applications
 
 ## Installation
 
 ```bash
+# Using npm
 npm install jotdb
-# or
-bun add jotdb
+
+# Using yarn
+yarn add jotdb
+
+# Using pnpm
+pnpm add jotdb
 ```
 
-## Usage
+## Full Example
 
 ```typescript
 import { JotDB } from 'jotdb';
 
-// In your Worker
-export interface Env {
-  JOTDB: DurableObjectNamespace;
-}
-
-export default {
-  async fetch(request: Request, env: Env) {
-    const id = env.JOTDB.idFromName("my-db");
-    const db = env.JOTDB.get(id);
-    
-    // Set a value
-    await db.set("key", "value");
-    
-    // Get a value
-    const value = await db.get("key");
-    
-    // Set schema
-    await db.setSchema({
-      name: "string",
-      age: "number",
-      email: "email"
-    });
-    
-    // Set multiple values
-    await db.setAll({
-      name: "John",
-      age: 30,
-      email: "john@example.com"
-    });
-  }
-};
-```
+// Initialize the database
+const jotId = env.JotDB.idFromName("my-db");
+const db = env.JotDB.get(jotId);
 
-## API
+// Set a value
+await db.set("user:123", { name: "John", age: 30 });
 
-### Methods
+// Get a value
+const user = await db.get("user:123");
+console.log(user); // { name: "John", age: 30 }
 
-- `get<T>(key: string): Promise<T | undefined>`
-- `set<T>(key: string, value: T): Promise<void>`
-- `getAll(): Promise<Record<string, unknown>>`
-- `setAll(obj: Record<string, unknown>): Promise<void>`
-- `delete(key: string): Promise<void>`
-- `clear(): Promise<void>`
-- `keys(): Promise<string[]>`
-- `has(key: string): Promise<boolean>`
-- `getSchema(): Promise<SchemaDefinition>`
-- `setSchema(schema: SchemaDefinition): Promise<void>`
-- `getOptions(): Promise<JotDBOptions>`
-- `setOptions(opts: Partial<JotDBOptions>): Promise<void>`
-- `getAuditLog(): Promise<AuditLogEntry[]>`
-- `clearAuditLog(): Promise<void>`
+// Delete a value
+await db.delete("user:123");
+```
 
-### Types
+## API Reference
 
-```typescript
-type SchemaType = "string" | "number" | "boolean" | "email" | "array" | "object" | "any";
-type SchemaDefinition = Record<string, SchemaType>;
+| Method | Description | Parameters | Returns |
+|--------|-------------|------------|---------|
+| `set(key, value)` | Store a value | `key: string`, `value: any` | `Promise<void>` |
+| `get(key)` | Retrieve a value | `key: string` | `Promise<any>` |
+| `delete(key)` | Remove a value | `key: string` | `Promise<void>` |
+| `list(prefix?)` | List all keys (optionally filtered by prefix) | `prefix?: string` | `Promise<string[]>` |
 
-interface JotDBOptions {
-  autoStrip: boolean;
-  readOnly: boolean;
-}
+## Types
 
-interface AuditLogEntry {
-  timestamp: number;
-  action: string;
-  keys: string[];
+```typescript
+interface JotDB {
+  set(key: string, value: any): Promise<void>;
+  get(key: string): Promise<any>;
+  delete(key: string): Promise<void>;
+  list(prefix?: string): Promise<string[]>;
 }
 ```
 
 ## License
 
-MIT
+MIT License - feel free to use this in your own projects!
 
 ## Contributing
 
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+
 1. Fork the repository
 2. Create your feature branch (`git checkout -b feature/amazing-feature`)
 3. Commit your changes (`git commit -m 'Add some amazing feature'`)
@@ -206,6 +81,8 @@ MIT
 
 ## Testing
 
-```bash
-bun test
-```
+Currently, testing is done manually in production. We're working on adding a comprehensive test suite. For now, you can test the functionality by:
+
+1. Deploying to Cloudflare Workers
+2. Using the example endpoints
+3. Verifying data persistence

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jotdb",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "main": "dist/index.js",
   "exports": {