jotdb 0.1.3 → 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/bun.lock

@@ -3,12 +3,10 @@
   "workspaces": {
     "": {
       "name": "jotdb",
-      "dependencies": {
-        "typescript": "^5.8.3",
-      },
       "devDependencies": {
         "@cloudflare/workers-types": "^4.20250517.0",
         "hono": "^4.7.10",
+        "typescript": "^5.8.3",
         "wrangler": "^4.15.2",
         "zod": "^3.24.4",
       },

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import type { DurableObjectState } from "@cloudflare/workers-types";
 import { Hono } from 'hono';
 import { DurableObject } from "cloudflare:workers";
 type SchemaType = "string" | "number" | "boolean" | "email" | "array" | "object" | "any";
@@ -18,14 +17,15 @@ export declare class JotDB extends DurableObject {
     private zodSchema;
     private options;
     private auditLog;
-    constructor(state: DurableObjectState, env: Env);
+    constructor(state: any, env: Env);
     load(): Promise<void>;
     save(): Promise<void>;
+    isArrayMode(): boolean;
+    push(item: unknown): Promise<void>;
+    setAll(objOrArr: Record<string, unknown> | unknown[]): Promise<void>;
+    getAll(): Promise<unknown>;
     logAudit(action: string, keys: string[] | string): Promise<void>;
     get<T = unknown>(key: string): Promise<T | undefined>;
-    getAll(): Promise<Record<string, unknown>>;
-    set<T>(key: string, value: T): Promise<void>;
-    setAll(obj: Record<string, unknown>): Promise<void>;
     delete(key: string): Promise<void>;
     clear(): Promise<void>;
     keys(): Promise<string[]>;
@@ -39,6 +39,7 @@ export declare class JotDB extends DurableObject {
     clearAuditLog(): Promise<void>;
     private buildZodSchema;
     fetch(request: Request): Promise<Response>;
+    set(key: string, value: unknown): Promise<void>;
 }
 export interface Env {
     JOTDB: DurableObjectNamespace;

package/dist/index.js

@@ -16,8 +16,8 @@ export class JotDB extends DurableObject {
         this.auditLog = [];
     }
     async load() {
-        if (Object.keys(this.data).length === 0) {
-            this.data = (await this.ctx.storage.get("data")) || {};
+        if (this.data == null || (typeof this.data === 'object' && Object.keys(this.data).length === 0)) {
+            this.data = (await this.ctx.storage.get("data")) ?? {};
         }
         if (Object.keys(this.rawSchema).length === 0) {
             this.rawSchema = (await this.ctx.storage.get("__schema__")) || {};
@@ -33,6 +33,31 @@ export class JotDB extends DurableObject {
     async save() {
         await this.ctx.storage.put("data", this.data);
     }
+    isArrayMode() {
+        return Array.isArray(this.data);
+    }
+    async push(item) {
+        await this.load();
+        if (!Array.isArray(this.data)) {
+            this.data = [];
+        }
+        this.data.push(item);
+        await this.save();
+        await this.logAudit("push", []);
+    }
+    async setAll(objOrArr) {
+        await this.load();
+        if (!Array.isArray(objOrArr) && this.zodSchema) {
+            objOrArr = this.zodSchema.parse(objOrArr);
+        }
+        this.data = objOrArr;
+        await this.save();
+        await this.logAudit("setAll", Array.isArray(objOrArr) ? [] : Object.keys(objOrArr));
+    }
+    async getAll() {
+        await this.load();
+        return this.data;
+    }
     async logAudit(action, keys) {
         const entry = {
             timestamp: Date.now(),
@@ -44,63 +69,18 @@ export class JotDB extends DurableObject {
     }
     async get(key) {
         await this.load();
-        return this.data[key];
-    }
-    async getAll() {
-        await this.load();
-        return this.data;
-    }
-    async set(key, value) {
-        await this.load();
-        if (this.options.readOnly)
-            throw new Error("JotDB is in read-only mode");
-        if (this.zodSchema) {
-            const partialSchema = this.zodSchema.pick({ [key]: true });
-            partialSchema.parse({ [key]: value });
-        }
-        this.data[key] = value;
-        await this.save();
-        await this.logAudit("set", key);
-    }
-    async setAll(obj) {
-        await this.load();
-        if (this.options.readOnly)
-            throw new Error("JotDB is in read-only mode");
-        const typeOfValue = (v) => {
-            if (Array.isArray(v))
-                return "array";
-            switch (typeof v) {
-                case "string": return "string";
-                case "number": return "number";
-                case "boolean": return "boolean";
-                case "object": return "object";
-                default: return "any";
-            }
-        };
-        if (!this.zodSchema) {
-            const inferred = {};
-            for (const [k, v] of Object.entries(obj)) {
-                inferred[k] = typeOfValue(v);
-            }
-            await this.setSchema(inferred);
+        if (!Array.isArray(this.data)) {
+            return this.data[key];
         }
-        if (this.zodSchema) {
-            if (this.options.autoStrip) {
-                obj = this.zodSchema.parse(obj); // returns stripped
-            }
-            else {
-                this.zodSchema.parse(obj); // strict match
-            }
-        }
-        Object.assign(this.data, obj);
-        await this.save();
-        await this.logAudit("setAll", Object.keys(obj));
+        return undefined;
     }
     async delete(key) {
         await this.load();
-        delete this.data[key];
-        await this.save();
-        await this.logAudit("delete", key);
+        if (!Array.isArray(this.data)) {
+            delete this.data[key];
+            await this.save();
+            await this.logAudit("delete", key);
+        }
     }
     async clear() {
         this.data = {};
@@ -109,11 +89,17 @@ export class JotDB extends DurableObject {
     }
     async keys() {
         await this.load();
-        return Object.keys(this.data);
+        if (!Array.isArray(this.data)) {
+            return Object.keys(this.data);
+        }
+        return [];
     }
     async has(key) {
         await this.load();
-        return key in this.data;
+        if (!Array.isArray(this.data)) {
+            return key in this.data;
+        }
+        return false;
     }
     async getSchema() {
         await this.load();
@@ -191,6 +177,23 @@ export class JotDB extends DurableObject {
     async fetch(request) {
         return new Response("Hello, World!");
     }
+    async set(key, value) {
+        await this.load();
+        if (this.options.readOnly) {
+            throw new Error("Database is in read-only mode");
+        }
+        if (!Array.isArray(this.data)) {
+            this.data[key] = value;
+            if (this.zodSchema) {
+                this.zodSchema.parse(this.data);
+            }
+            await this.save();
+            await this.logAudit("set", key);
+        }
+        else {
+            throw new Error("Cannot use set() in array mode");
+        }
+    }
 }
 const app = new Hono();
 // Middleware

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jotdb",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -11,15 +11,12 @@
   },
   "types": "dist/index.d.ts",
   "scripts": {
-    "dev": "wrangler dev --port 5173 --remote",
-    "test": "bun test jotdb.tests.ts",
+    "dev": "wrangler dev --port 5173",
     "deploy": "wrangler deploy",
     "patch": "npm version patch && npm publish --access public"
   },
-  "dependencies": {
-    "typescript": "^5.8.3"
-  },
   "devDependencies": {
+    "typescript": "^5.8.3",
     "@cloudflare/workers-types": "^4.20250517.0",
     "hono": "^4.7.10",
     "wrangler": "^4.15.2",

package/src/index.ts

@@ -20,7 +20,7 @@ interface AuditLogEntry {
 }
 
 export class JotDB extends DurableObject {
-  private data: Record<string, unknown> = {};
+  private data: Record<string, unknown> | unknown[] = {};
   private rawSchema: SchemaDefinition = {};
   private zodSchema: ZodObject<any> | null = null;
   private options: JotDBOptions = {
@@ -34,8 +34,8 @@ export class JotDB extends DurableObject {
   }
 
   async load(): Promise<void> {
-    if (Object.keys(this.data).length === 0) {
-      this.data = (await this.ctx.storage.get("data")) || {};
+    if (this.data == null || (typeof this.data === 'object' && Object.keys(this.data).length === 0)) {
+      this.data = (await this.ctx.storage.get("data")) ?? {};
     }
     if (Object.keys(this.rawSchema).length === 0) {
       this.rawSchema = (await this.ctx.storage.get("__schema__")) || {};
@@ -45,7 +45,6 @@ export class JotDB extends DurableObject {
     }
     const storedOptions = await this.ctx.storage.get("__options__") as JotDBOptions | null;
     if (storedOptions) this.options = storedOptions;
-
     this.auditLog = (await this.ctx.storage.get("__audit__")) || [];
   }
 
@@ -53,80 +52,60 @@ export class JotDB extends DurableObject {
     await this.ctx.storage.put("data", this.data);
   }
 
-  async logAudit(action: string, keys: string[] | string): Promise<void> {
-    const entry: AuditLogEntry = {
-      timestamp: Date.now(),
-      action,
-      keys: Array.isArray(keys) ? keys : [keys],
-    };
-    this.auditLog.unshift(entry);
-    await this.ctx.storage.put("__audit__", this.auditLog.slice(0, 100)); // keep max 100 entries
-  }
-
-  async get<T = unknown>(key: string): Promise<T | undefined> {
-    await this.load();
-    return this.data[key] as T;
+  isArrayMode(): boolean {
+    return Array.isArray(this.data);
   }
 
-  async getAll(): Promise<Record<string, unknown>> {
+  async push(item: unknown): Promise<void> {
     await this.load();
-    return this.data;
+    if (!Array.isArray(this.data)) {
+      this.data = [];
+    }
+    (this.data as unknown[]).push(item);
+    await this.save();
+    await this.logAudit("push", []);
   }
 
-  async set<T>(key: string, value: T): Promise<void> {
+  async setAll(objOrArr: Record<string, unknown> | unknown[]): Promise<void> {
     await this.load();
-    if (this.options.readOnly) throw new Error("JotDB is in read-only mode");
-
-    if (this.zodSchema) {
-      const partialSchema = this.zodSchema.pick({ [key]: true });
-      partialSchema.parse({ [key]: value });
+    if (!Array.isArray(objOrArr) && this.zodSchema) {
+      objOrArr = this.zodSchema.parse(objOrArr);
     }
-    this.data[key] = value;
+    this.data = objOrArr;
     await this.save();
-    await this.logAudit("set", key);
+    await this.logAudit("setAll", Array.isArray(objOrArr) ? [] : Object.keys(objOrArr));
   }
 
-  async setAll(obj: Record<string, unknown>): Promise<void> {
+  async getAll(): Promise<unknown> {
     await this.load();
-    if (this.options.readOnly) throw new Error("JotDB is in read-only mode");
-
-    const typeOfValue = (v: any): string => {
-      if (Array.isArray(v)) return "array";
-      switch (typeof v) {
-        case "string": return "string";
-        case "number": return "number";
-        case "boolean": return "boolean";
-        case "object": return "object";
-        default: return "any";
-      }
-    };
+    return this.data;
+  }
 
-    if (!this.zodSchema) {
-      const inferred: SchemaDefinition = {};
-      for (const [k, v] of Object.entries(obj)) {
-        inferred[k] = typeOfValue(v) as SchemaType;
-      }
-      await this.setSchema(inferred);
-    }
+  async logAudit(action: string, keys: string[] | string): Promise<void> {
+    const entry: AuditLogEntry = {
+      timestamp: Date.now(),
+      action,
+      keys: Array.isArray(keys) ? keys : [keys],
+    };
+    this.auditLog.unshift(entry);
+    await this.ctx.storage.put("__audit__", this.auditLog.slice(0, 100)); // keep max 100 entries
+  }
 
-    if (this.zodSchema) {
-      if (this.options.autoStrip) {
-        obj = this.zodSchema.parse(obj); // returns stripped
-      } else {
-        this.zodSchema.parse(obj); // strict match
-      }
+  async get<T = unknown>(key: string): Promise<T | undefined> {
+    await this.load();
+    if (!Array.isArray(this.data)) {
+      return this.data[key] as T;
     }
-
-    Object.assign(this.data, obj);
-    await this.save();
-    await this.logAudit("setAll", Object.keys(obj));
+    return undefined;
   }
 
   async delete(key: string): Promise<void> {
     await this.load();
-    delete this.data[key];
-    await this.save();
-    await this.logAudit("delete", key);
+    if (!Array.isArray(this.data)) {
+      delete this.data[key];
+      await this.save();
+      await this.logAudit("delete", key);
+    }
   }
 
   async clear(): Promise<void> {
@@ -137,12 +116,18 @@ export class JotDB extends DurableObject {
 
   async keys(): Promise<string[]> {
     await this.load();
-    return Object.keys(this.data);
+    if (!Array.isArray(this.data)) {
+      return Object.keys(this.data);
+    }
+    return [];
   }
 
   async has(key: string): Promise<boolean> {
     await this.load();
-    return key in this.data;
+    if (!Array.isArray(this.data)) {
+      return key in this.data;
+    }
+    return false;
   }
 
   async getSchema(): Promise<SchemaDefinition> {
@@ -230,6 +215,23 @@ export class JotDB extends DurableObject {
   async fetch(request: Request) {
     return new Response("Hello, World!");
   }
+
+  async set(key: string, value: unknown): Promise<void> {
+    await this.load();
+    if (this.options.readOnly) {
+      throw new Error("Database is in read-only mode");
+    }
+    if (!Array.isArray(this.data)) {
+      this.data[key] = value;
+      if (this.zodSchema) {
+        this.zodSchema.parse(this.data);
+      }
+      await this.save();
+      await this.logAudit("set", key);
+    } else {
+      throw new Error("Cannot use set() in array mode");
+    }
+  }
 }
 
 export interface Env {
@@ -274,7 +276,7 @@ app.get('/test', async (c) => {
       age: 30,
       email: "john@example.com"
     });
-    const all = await db.getAll();
+    const all = await db.getAll() as { name: string, age: number, email: string };
     results.tests.push({
       name: "Schema validation",
       passed: all.name === "John" && all.age === 30,
@@ -306,23 +308,71 @@ app.get('/test', async (c) => {
       email: "jane@example.com",
       extra: "should be stripped"
     });
-    const stripped = await db.getAll();
+    const stripped = await db.getAll() as { name: string, age: number, email: string };
     results.tests.push({
       name: "Auto-strip mode",
       passed: !("extra" in stripped),
       value: stripped
     });
 
+    // Test 5: Array mode - setAll and getAll
+    const arrayId = c.env.JOTDB.idFromName("test-array");
+    const arrayDb = c.env.JOTDB.get(arrayId) as unknown as JotDB;
+    await arrayDb.setAll([1, 2, 3]);
+    const arr = await arrayDb.getAll();
+    results.tests.push({
+      name: "Array mode setAll/getAll",
+      passed: Array.isArray(arr) && arr.length === 3 && arr[0] === 1 && arr[2] === 3,
+      value: arr
+    });
+
+    // Test 6: Array mode - push
+    await arrayDb.push(4);
+    const arr2 = await arrayDb.getAll();
+    results.tests.push({
+      name: "Array mode push",
+      passed: Array.isArray(arr2) && arr2.length === 4 && arr2[3] === 4,
+      value: arr2
+    });
+
     // Get audit log
     results.auditLog = await db.getAuditLog();
 
-    return c.json(results);
+    // HTML output
+    let html = `<!DOCTYPE html><html><head><title>JotDB Test Results</title>
+    <style>
+      body { font-family: sans-serif; margin: 2em; }
+      .pass { color: green; }
+      .fail { color: red; }
+      .test { margin-bottom: 1em; }
+      pre { background: #f4f4f4; padding: 0.5em; }
+    </style>
+    </head><body>
+    <h1>JotDB Test Results</h1>
+    <p><b>Timestamp:</b> ${new Date(results.timestamp).toLocaleString()}</p>
+    <div>
+      ${results.tests.map(test => `
+        <div class="test">
+          <b>${test.name}:</b> <span class="${test.passed ? 'pass' : 'fail'}">${test.passed ? 'PASS' : 'FAIL'}</span><br/>
+          <pre>${JSON.stringify(test.value ?? test.error, null, 2)}</pre>
+        </div>
+      `).join('')}
+    </div>
+    <h2>Audit Log</h2>
+    <pre>${JSON.stringify(results.auditLog, null, 2)}</pre>
+    </body></html>`;
+
+    return new Response(html, { headers: { 'Content-Type': 'text/html' } });
   } catch (error) {
-    return c.json({
-      error: error instanceof Error ? error.message : String(error),
-      tests: results.tests,
-      auditLog: results.auditLog
-    }, 500);
+    let html = `<!DOCTYPE html><html><head><title>JotDB Test Error</title></head><body>` +
+      `<h1 style="color:red">Error</h1>` +
+      `<pre>${error instanceof Error ? error.message : String(error)}</pre>` +
+      `<h2>Partial Results</h2>` +
+      `<pre>${JSON.stringify(results.tests, null, 2)}</pre>` +
+      `<h2>Audit Log</h2>` +
+      `<pre>${JSON.stringify(results.auditLog, null, 2)}</pre>` +
+      `</body></html>`;
+    return new Response(html, { headers: { 'Content-Type': 'text/html' } });
   }
 });
 

package/jotdb.tests.ts

@@ -1,63 +0,0 @@
-import { assert, describe, it, beforeEach } from "bun:test";
-import { JotDB } from "./src/index.ts";
-
-// Fake DurableObjectState stub for unit testing
-function createFakeState(): any {
-  let store: Record<string, any> = {};
-  return {
-    storage: {
-      get: async (k: string) => store[k],
-      put: async (k: string, v: any) => { store[k] = v },
-    }
-  };
-}
-
-describe("JotDB", () => {
-  let jot: JotDB;
-
-  beforeEach(() => {
-    jot = new JotDB(createFakeState());
-  });
-
-  it("should set and get a value", async () => {
-    await jot.set("foo", "bar");
-    const val = await jot.get("foo");
-    assert(val === "bar");
-  });
-
-  it("should support setAll and getAll", async () => {
-    await jot.setAll({ a: 1, b: true });
-    const all = await jot.getAll();
-    assert(all.a === 1);
-    assert(all.b === true);
-  });
-
-  it("should enforce schema after inference", async () => {
-    await jot.setAll({ x: "yes", y: 2 });
-    await assert.rejects(() => jot.set("y", "not a number"));
-  });
-
-  it("should strip unknowns if autoStrip is on", async () => {
-    await jot.setAll({ known: "yes" });
-    await jot.setOptions({ autoStrip: true });
-    await jot.setAll({ known: "ok", extra: "skip" });
-    const data = await jot.getAll();
-    assert(data.known === "ok");
-    assert(!("extra" in data));
-  });
-
-  it("should block writes if readOnly is on", async () => {
-    await jot.setAll({ z: 9 });
-    await jot.setOptions({ readOnly: true });
-    await assert.rejects(() => jot.set("z", 10));
-  });
-
-  it("should track audit logs", async () => {
-    await jot.set("a", 1);
-    await jot.setAll({ b: 2, c: 3 });
-    const log = await jot.getAuditLog();
-    assert(log.length >= 2);
-    assert(log[0].action === "setAll");
-    assert(log[1].action === "set");
-  });
-});