jotdb 0.1.0 → 0.1.2

package/bun.lock

@@ -3,6 +3,9 @@
   "workspaces": {
     "": {
       "name": "jotdb",
+      "dependencies": {
+        "typescript": "^5.8.3",
+      },
       "devDependencies": {
         "@cloudflare/workers-types": "^4.20250517.0",
         "hono": "^4.7.10",
@@ -196,6 +199,8 @@
 
     "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
 
+    "typescript": ["typescript@5.8.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ=="],
+
     "ufo": ["ufo@1.6.1", "", {}, "sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA=="],
 
     "undici": ["undici@5.29.0", "", { "dependencies": { "@fastify/busboy": "^2.0.0" } }, "sha512-raqeBD6NQK4SkWhQzeYKd1KmIG6dllBOTt55Rmkt4HtI9mwdWtJljnrXjAFUBLTSN67HWrOIZ3EPF4kjUw80Bg=="],

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+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";
+type SchemaDefinition = Record<string, SchemaType>;
+interface JotDBOptions {
+    autoStrip: boolean;
+    readOnly: boolean;
+}
+interface AuditLogEntry {
+    timestamp: number;
+    action: string;
+    keys: string[];
+}
+export declare class JotDB extends DurableObject {
+    private data;
+    private rawSchema;
+    private zodSchema;
+    private options;
+    private auditLog;
+    constructor(state: DurableObjectState, env: Env);
+    load(): Promise<void>;
+    save(): Promise<void>;
+    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[]>;
+    has(key: string): Promise<boolean>;
+    getSchema(): Promise<SchemaDefinition>;
+    private warnSchemaDiff;
+    setSchema(schemaObj: SchemaDefinition): Promise<void>;
+    setOptions(opts: Partial<JotDBOptions>): Promise<void>;
+    getOptions(): Promise<JotDBOptions>;
+    getAuditLog(): Promise<AuditLogEntry[]>;
+    clearAuditLog(): Promise<void>;
+    private buildZodSchema;
+    fetch(request: Request): Promise<Response>;
+}
+export interface Env {
+    JOTDB: DurableObjectNamespace;
+}
+declare const app: Hono<{
+    Bindings: Env;
+}, import("hono/types").BlankSchema, "/">;
+export default app;

package/dist/index.js

@@ -0,0 +1,279 @@
+import { z } from "zod";
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { prettyJSON } from 'hono/pretty-json';
+import { DurableObject } from "cloudflare:workers";
+export class JotDB extends DurableObject {
+    constructor(state, env) {
+        super(state, env);
+        this.data = {};
+        this.rawSchema = {};
+        this.zodSchema = null;
+        this.options = {
+            autoStrip: false,
+            readOnly: false,
+        };
+        this.auditLog = [];
+    }
+    async load() {
+        if (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__")) || {};
+            if (Object.keys(this.rawSchema).length > 0) {
+                this.zodSchema = this.buildZodSchema(this.rawSchema);
+            }
+        }
+        const storedOptions = await this.ctx.storage.get("__options__");
+        if (storedOptions)
+            this.options = storedOptions;
+        this.auditLog = (await this.ctx.storage.get("__audit__")) || [];
+    }
+    async save() {
+        await this.ctx.storage.put("data", this.data);
+    }
+    async logAudit(action, keys) {
+        const entry = {
+            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(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 (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));
+    }
+    async delete(key) {
+        await this.load();
+        delete this.data[key];
+        await this.save();
+        await this.logAudit("delete", key);
+    }
+    async clear() {
+        this.data = {};
+        await this.save();
+        await this.logAudit("clear", []);
+    }
+    async keys() {
+        await this.load();
+        return Object.keys(this.data);
+    }
+    async has(key) {
+        await this.load();
+        return key in this.data;
+    }
+    async getSchema() {
+        await this.load();
+        return this.rawSchema;
+    }
+    warnSchemaDiff(newSchema) {
+        const current = this.rawSchema;
+        for (const key in newSchema) {
+            if (!(key in current))
+                console.warn(`[JotDB] New key added: ${key}`);
+            else if (newSchema[key] !== current[key]) {
+                console.warn(`[JotDB] Type changed for "${key}": ${current[key]} → ${newSchema[key]}`);
+            }
+        }
+        for (const key in current) {
+            if (!(key in newSchema)) {
+                console.warn(`[JotDB] Key removed: ${key}`);
+            }
+        }
+    }
+    async setSchema(schemaObj) {
+        await this.load();
+        if (Object.keys(this.rawSchema).length > 0) {
+            this.warnSchemaDiff(schemaObj);
+        }
+        this.rawSchema = schemaObj;
+        this.zodSchema = this.buildZodSchema(schemaObj);
+        await this.ctx.storage.put("__schema__", schemaObj);
+    }
+    async setOptions(opts) {
+        await this.load();
+        Object.assign(this.options, opts);
+        await this.ctx.storage.put("__options__", this.options);
+    }
+    async getOptions() {
+        await this.load();
+        return this.options;
+    }
+    async getAuditLog() {
+        await this.load();
+        return this.auditLog;
+    }
+    async clearAuditLog() {
+        this.auditLog = [];
+        await this.ctx.storage.put("__audit__", []);
+    }
+    buildZodSchema(schema) {
+        const shape = {};
+        for (const [key, type] of Object.entries(schema)) {
+            switch (type) {
+                case "string":
+                    shape[key] = z.string();
+                    break;
+                case "number":
+                    shape[key] = z.number();
+                    break;
+                case "boolean":
+                    shape[key] = z.boolean();
+                    break;
+                case "email":
+                    shape[key] = z.string().email();
+                    break;
+                case "array":
+                    shape[key] = z.array(z.any());
+                    break;
+                case "object":
+                    shape[key] = z.record(z.any());
+                    break;
+                default:
+                    shape[key] = z.any();
+            }
+        }
+        return z.object(shape);
+    }
+    async fetch(request) {
+        return new Response("Hello, World!");
+    }
+}
+const app = new Hono();
+// Middleware
+app.use('*', cors());
+app.use('*', prettyJSON());
+// Test endpoint
+app.get('/test', async (c) => {
+    const id = c.env.JOTDB.idFromName("test-db");
+    const db = c.env.JOTDB.get(id);
+    const results = {
+        timestamp: Date.now(),
+        tests: [],
+        auditLog: []
+    };
+    try {
+        // Test 1: Basic set/get
+        await db.set("test1", "hello");
+        const value1 = await db.get("test1");
+        results.tests.push({
+            name: "Basic set/get",
+            passed: value1 === "hello",
+            value: value1
+        });
+        // Test 2: Schema validation
+        await db.setSchema({
+            name: "string",
+            age: "number",
+            email: "email"
+        });
+        await db.setAll({
+            name: "John",
+            age: 30,
+            email: "john@example.com"
+        });
+        const all = await db.getAll();
+        results.tests.push({
+            name: "Schema validation",
+            passed: all.name === "John" && all.age === 30,
+            value: all
+        });
+        // Test 3: Read-only mode
+        await db.setOptions({ readOnly: true });
+        try {
+            await db.set("test3", "should fail");
+            results.tests.push({
+                name: "Read-only mode",
+                passed: false,
+                error: "Should have thrown"
+            });
+        }
+        catch (e) {
+            results.tests.push({
+                name: "Read-only mode",
+                passed: true,
+                error: e instanceof Error ? e.message : String(e)
+            });
+        }
+        // Test 4: Auto-strip mode
+        await db.setOptions({ readOnly: false, autoStrip: true });
+        await db.setAll({
+            name: "Jane",
+            age: 25,
+            email: "jane@example.com",
+            extra: "should be stripped"
+        });
+        const stripped = await db.getAll();
+        results.tests.push({
+            name: "Auto-strip mode",
+            passed: !("extra" in stripped),
+            value: stripped
+        });
+        // Get audit log
+        results.auditLog = await db.getAuditLog();
+        return c.json(results);
+    }
+    catch (error) {
+        return c.json({
+            error: error instanceof Error ? error.message : String(error),
+            tests: results.tests,
+            auditLog: results.auditLog
+        }, 500);
+    }
+});
+// Health check endpoint
+app.get('/', (c) => c.text('JotDB Durable Object'));
+export default app;

package/jotdb.tests.ts

@@ -1,5 +1,5 @@
 import { assert, describe, it, beforeEach } from "bun:test";
-import { JotDB } from "./src/JotDB.ts";
+import { JotDB } from "./src/index.ts";
 
 // Fake DurableObjectState stub for unit testing
 function createFakeState(): any {

package/package.json

@@ -1,17 +1,29 @@
 {
   "name": "jotdb",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "types": "dist/index.d.ts",
   "scripts": {
     "dev": "wrangler dev --port 5173 --remote",
     "test": "bun test jotdb.tests.ts",
-    "deploy": "wrangler deploy"
+    "deploy": "wrangler deploy",
+    "patch": "npm version patch && npm publish --access public"
+  },
+  "dependencies": {
+    "typescript": "^5.8.3"
   },
-  "dependencies": {},
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20250517.0",
     "hono": "^4.7.10",
     "wrangler": "^4.15.2",
     "zod": "^3.24.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/acoyfellow/jotdb.git"
   }
 }

package/src/index.ts

@@ -1,5 +1,4 @@
 import { z, ZodTypeAny, ZodObject } from "zod";
-import type { DurableObjectState } from "@cloudflare/workers-types";
 import { Hono } from 'hono';
 import { cors } from 'hono/cors';
 import { prettyJSON } from 'hono/pretty-json';
@@ -21,7 +20,6 @@ interface AuditLogEntry {
 }
 
 export class JotDB extends DurableObject {
-  private ctx: DurableObjectState;
   private data: Record<string, unknown> = {};
   private rawSchema: SchemaDefinition = {};
   private zodSchema: ZodObject<any> | null = null;
@@ -31,9 +29,8 @@ export class JotDB extends DurableObject {
   };
   private auditLog: AuditLogEntry[] = [];
 
-  constructor(state: DurableObjectState, env: Env) {
+  constructor(state: any, env: Env) {
     super(state, env);
-    this.ctx = state;
   }
 
   async load(): Promise<void> {
@@ -229,6 +226,10 @@ export class JotDB extends DurableObject {
     }
     return z.object(shape);
   }
+
+  async fetch(request: Request) {
+    return new Response("Hello, World!");
+  }
 }
 
 export interface Env {

package/tsconfig.json

@@ -1,13 +1,16 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "ES2020",
+    "module": "ESNext",
     "lib": [
       "ES2020"
     ],
     "types": [
       "@cloudflare/workers-types"
     ],
+    "declaration": true,
+    "emitDeclarationOnly": false,
+    "outDir": "dist",
     "moduleResolution": "node",
     "strict": true,
     "noImplicitAny": true,

package/wrangler.jsonc

@@ -2,7 +2,6 @@
   "$schema": "node_modules/wrangler/config-schema.json",
   "name": "jotdb",
   "main": "src/index.ts",
-  "account_id": "bfcb6ac5b3ceaf42a09607f6f7925823",
   "compatibility_date": "2024-05-01",
   "compatibility_flags": [
     "nodejs_compat"