jotdb 0.1.3 → 0.1.4

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.4",
   "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");
-  });
-});