covara 0.0.1 → 0.6.0

package/dist/kv/durable-object.js

@@ -0,0 +1,1059 @@
+/**
+ * Cloudflare Durable Object KV Store Implementation
+ *
+ * Backs the KV adapter interface with a single Durable Object instance.
+ * The module is structured in three layers:
+ *
+ * 1. DurableKVEngine - executes KV operations against Durable Object storage.
+ *    Collections are stored one storage entry per member because Durable
+ *    Object storage caps individual values at 128KB.
+ * 2. CovaraKVDurableObject - the Durable Object class. Users re-export it
+ *    from their worker entry and bind it in wrangler.toml. Handles batched
+ *    commands over POST /batch and pub/sub over hibernating WebSockets.
+ * 3. DurableObjectKVStore - the KVAdapter implementation that talks to the
+ *    Durable Object via its stub.
+ *
+ * This module deliberately has zero Cloudflare imports so it stays
+ * compilable and testable under Node. Cloudflare-specific globals
+ * (WebSocketPair) are resolved at runtime via globalThis.
+ */
+// NUL never appears in real keys, unlike spaces or colons
+const SEP = "\u0000";
+const COLLECTION_PREFIX = {
+    hash: "h",
+    set: "e",
+    list: "l",
+    zset: "z",
+};
+const LIST_INDEX_BASE = 2 ** 42;
+const padListIndex = (position) => String(LIST_INDEX_BASE + position).padStart(14, "0");
+const globToRegex = (pattern) => {
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`);
+};
+export class DurableKVEngine {
+    constructor(storage) {
+        this.storage = storage;
+    }
+    stringKey(key) {
+        return `s${SEP}${key}`;
+    }
+    metaKey(key) {
+        return `m${SEP}${key}`;
+    }
+    memberKey(type, key, member) {
+        return `${COLLECTION_PREFIX[type]}${SEP}${key}${SEP}${member}`;
+    }
+    memberPrefix(type, key) {
+        return `${COLLECTION_PREFIX[type]}${SEP}${key}${SEP}`;
+    }
+    async deleteMembers(type, key) {
+        const entries = await this.storage.list({
+            prefix: this.memberPrefix(type, key),
+        });
+        for (const storageKey of entries.keys()) {
+            await this.storage.delete(storageKey);
+        }
+    }
+    async deleteLogicalKey(key) {
+        let deleted = false;
+        if (await this.storage.delete(this.stringKey(key))) {
+            deleted = true;
+        }
+        const meta = await this.storage.get(this.metaKey(key));
+        if (meta) {
+            await this.deleteMembers(meta.type, key);
+            await this.storage.delete(this.metaKey(key));
+            deleted = true;
+        }
+        return deleted;
+    }
+    async readString(key) {
+        const entry = await this.storage.get(this.stringKey(key));
+        if (!entry)
+            return null;
+        if (entry.exp !== undefined && Date.now() > entry.exp) {
+            await this.storage.delete(this.stringKey(key));
+            return null;
+        }
+        return entry;
+    }
+    async readMeta(key) {
+        const meta = await this.storage.get(this.metaKey(key));
+        if (!meta)
+            return null;
+        if (meta.exp !== undefined && Date.now() > meta.exp) {
+            await this.deleteMembers(meta.type, key);
+            await this.storage.delete(this.metaKey(key));
+            return null;
+        }
+        return meta;
+    }
+    async readMetaOfType(key, type) {
+        const meta = await this.readMeta(key);
+        return meta?.type === type ? meta : null;
+    }
+    async prepareCollection(key, type) {
+        const existing = await this.readMeta(key);
+        if (existing?.type === type)
+            return existing;
+        await this.deleteLogicalKey(key);
+        const meta = type === "list" ? { type, head: 0, tail: 0 } : { type };
+        await this.storage.put(this.metaKey(key), meta);
+        return meta;
+    }
+    async get(key) {
+        return (await this.readString(key))?.v ?? null;
+    }
+    async set(key, value, options) {
+        const stringEntry = await this.readString(key);
+        const meta = await this.readMeta(key);
+        const exists = stringEntry !== null || meta !== null;
+        if (options?.nx && exists)
+            return "OK";
+        if (options?.xx && !exists)
+            return "OK";
+        let exp;
+        if (options?.ex) {
+            exp = Date.now() + options.ex * 1000;
+        }
+        else if (options?.px) {
+            exp = Date.now() + options.px;
+        }
+        if (meta) {
+            await this.deleteLogicalKey(key);
+        }
+        const entry = exp === undefined ? { v: value } : { v: value, exp };
+        await this.storage.put(this.stringKey(key), entry);
+        return "OK";
+    }
+    async del(...keys) {
+        let deleted = 0;
+        for (const key of keys) {
+            if (await this.deleteLogicalKey(key))
+                deleted++;
+        }
+        return deleted;
+    }
+    async exists(...keys) {
+        let count = 0;
+        for (const key of keys) {
+            if ((await this.readString(key)) !== null || (await this.readMeta(key)) !== null) {
+                count++;
+            }
+        }
+        return count;
+    }
+    async incr(key) {
+        return this.incrBy(key, 1);
+    }
+    async incrBy(key, increment) {
+        const stringEntry = await this.readString(key);
+        let exp = stringEntry?.exp;
+        if (!stringEntry) {
+            const meta = await this.readMeta(key);
+            if (meta) {
+                exp = meta.exp;
+                await this.deleteLogicalKey(key);
+            }
+        }
+        const current = stringEntry ? parseInt(stringEntry.v, 10) : 0;
+        const value = current + increment;
+        const entry = exp === undefined ? { v: String(value) } : { v: String(value), exp };
+        await this.storage.put(this.stringKey(key), entry);
+        return value;
+    }
+    async decr(key) {
+        return this.incrBy(key, -1);
+    }
+    async expire(key, seconds) {
+        const exp = Date.now() + seconds * 1000;
+        const stringEntry = await this.readString(key);
+        if (stringEntry) {
+            await this.storage.put(this.stringKey(key), { ...stringEntry, exp });
+            return true;
+        }
+        const meta = await this.readMeta(key);
+        if (meta) {
+            await this.storage.put(this.metaKey(key), { ...meta, exp });
+            return true;
+        }
+        return false;
+    }
+    async ttl(key) {
+        const stringEntry = await this.readString(key);
+        const entry = stringEntry ?? (await this.readMeta(key));
+        if (!entry)
+            return -2;
+        if (entry.exp === undefined)
+            return -1;
+        const remaining = Math.ceil((entry.exp - Date.now()) / 1000);
+        return remaining > 0 ? remaining : -2;
+    }
+    async hget(key, field) {
+        const meta = await this.readMetaOfType(key, "hash");
+        if (!meta)
+            return null;
+        const value = await this.storage.get(this.memberKey("hash", key, field));
+        return value ?? null;
+    }
+    async hset(key, field, value) {
+        await this.prepareCollection(key, "hash");
+        const fieldKey = this.memberKey("hash", key, field);
+        const existing = await this.storage.get(fieldKey);
+        await this.storage.put(fieldKey, value);
+        return existing === undefined ? 1 : 0;
+    }
+    async hmset(key, data) {
+        await this.prepareCollection(key, "hash");
+        for (const [field, value] of Object.entries(data)) {
+            await this.storage.put(this.memberKey("hash", key, field), value);
+        }
+    }
+    async hgetall(key) {
+        const meta = await this.readMetaOfType(key, "hash");
+        if (!meta)
+            return {};
+        const prefix = this.memberPrefix("hash", key);
+        const entries = await this.storage.list({ prefix });
+        const result = {};
+        for (const [storageKey, value] of entries) {
+            result[storageKey.slice(prefix.length)] = value;
+        }
+        return result;
+    }
+    async hdel(key, ...fields) {
+        const meta = await this.readMetaOfType(key, "hash");
+        if (!meta)
+            return 0;
+        let deleted = 0;
+        for (const field of fields) {
+            if (await this.storage.delete(this.memberKey("hash", key, field))) {
+                deleted++;
+            }
+        }
+        return deleted;
+    }
+    async hexists(key, field) {
+        const meta = await this.readMetaOfType(key, "hash");
+        if (!meta)
+            return false;
+        const value = await this.storage.get(this.memberKey("hash", key, field));
+        return value !== undefined;
+    }
+    async hkeys(key) {
+        return Object.keys(await this.hgetall(key));
+    }
+    async hlen(key) {
+        return (await this.hkeys(key)).length;
+    }
+    async sadd(key, ...members) {
+        await this.prepareCollection(key, "set");
+        let added = 0;
+        for (const member of members) {
+            const memberKey = this.memberKey("set", key, member);
+            const existing = await this.storage.get(memberKey);
+            if (existing === undefined) {
+                await this.storage.put(memberKey, 1);
+                added++;
+            }
+        }
+        return added;
+    }
+    async srem(key, ...members) {
+        const meta = await this.readMetaOfType(key, "set");
+        if (!meta)
+            return 0;
+        let removed = 0;
+        for (const member of members) {
+            if (await this.storage.delete(this.memberKey("set", key, member))) {
+                removed++;
+            }
+        }
+        return removed;
+    }
+    async smembers(key) {
+        const meta = await this.readMetaOfType(key, "set");
+        if (!meta)
+            return [];
+        const prefix = this.memberPrefix("set", key);
+        const entries = await this.storage.list({ prefix });
+        return [...entries.keys()].map((storageKey) => storageKey.slice(prefix.length));
+    }
+    async sismember(key, member) {
+        const meta = await this.readMetaOfType(key, "set");
+        if (!meta)
+            return false;
+        const value = await this.storage.get(this.memberKey("set", key, member));
+        return value !== undefined;
+    }
+    async scard(key) {
+        return (await this.smembers(key)).length;
+    }
+    async lpush(key, ...values) {
+        const meta = await this.prepareCollection(key, "list");
+        let head = meta.head ?? 0;
+        const tail = meta.tail ?? 0;
+        for (const value of values) {
+            head -= 1;
+            await this.storage.put(this.memberKey("list", key, padListIndex(head)), value);
+        }
+        await this.storage.put(this.metaKey(key), { ...meta, head, tail });
+        return tail - head;
+    }
+    async rpush(key, ...values) {
+        const meta = await this.prepareCollection(key, "list");
+        const head = meta.head ?? 0;
+        let tail = meta.tail ?? 0;
+        for (const value of values) {
+            await this.storage.put(this.memberKey("list", key, padListIndex(tail)), value);
+            tail += 1;
+        }
+        await this.storage.put(this.metaKey(key), { ...meta, head, tail });
+        return tail - head;
+    }
+    async lpop(key) {
+        const meta = await this.readMetaOfType(key, "list");
+        if (!meta)
+            return null;
+        const head = meta.head ?? 0;
+        const tail = meta.tail ?? 0;
+        if (head >= tail)
+            return null;
+        const storageKey = this.memberKey("list", key, padListIndex(head));
+        const value = (await this.storage.get(storageKey)) ?? null;
+        await this.storage.delete(storageKey);
+        await this.storage.put(this.metaKey(key), { ...meta, head: head + 1 });
+        return value;
+    }
+    async rpop(key) {
+        const meta = await this.readMetaOfType(key, "list");
+        if (!meta)
+            return null;
+        const head = meta.head ?? 0;
+        const tail = meta.tail ?? 0;
+        if (head >= tail)
+            return null;
+        const storageKey = this.memberKey("list", key, padListIndex(tail - 1));
+        const value = (await this.storage.get(storageKey)) ?? null;
+        await this.storage.delete(storageKey);
+        await this.storage.put(this.metaKey(key), { ...meta, tail: tail - 1 });
+        return value;
+    }
+    async loadList(key) {
+        const meta = await this.readMetaOfType(key, "list");
+        if (!meta)
+            return [];
+        const entries = await this.storage.list({
+            prefix: this.memberPrefix("list", key),
+        });
+        return [...entries.values()];
+    }
+    async lrange(key, start, stop) {
+        const list = await this.loadList(key);
+        const len = list.length;
+        const s = start < 0 ? Math.max(len + start, 0) : start;
+        const e = stop < 0 ? len + stop : stop;
+        return list.slice(s, e + 1);
+    }
+    async llen(key) {
+        const meta = await this.readMetaOfType(key, "list");
+        if (!meta)
+            return 0;
+        return (meta.tail ?? 0) - (meta.head ?? 0);
+    }
+    async ltrim(key, start, stop) {
+        const meta = await this.readMetaOfType(key, "list");
+        if (!meta)
+            return;
+        const entries = await this.storage.list({
+            prefix: this.memberPrefix("list", key),
+        });
+        const storageKeys = [...entries.keys()];
+        const len = storageKeys.length;
+        const s = start < 0 ? Math.max(len + start, 0) : start;
+        const e = stop < 0 ? len + stop : stop;
+        const keepFrom = Math.max(s, 0);
+        const keepTo = Math.min(e, len - 1);
+        for (let i = 0; i < len; i++) {
+            if (i < keepFrom || i > keepTo) {
+                await this.storage.delete(storageKeys[i]);
+            }
+        }
+        const head = meta.head ?? 0;
+        if (keepFrom > keepTo) {
+            await this.storage.put(this.metaKey(key), { ...meta, head: 0, tail: 0 });
+        }
+        else {
+            await this.storage.put(this.metaKey(key), {
+                ...meta,
+                head: head + keepFrom,
+                tail: head + keepTo + 1,
+            });
+        }
+    }
+    async loadZSet(key) {
+        const meta = await this.readMetaOfType(key, "zset");
+        if (!meta)
+            return [];
+        const prefix = this.memberPrefix("zset", key);
+        const entries = await this.storage.list({ prefix });
+        const members = [...entries].map(([storageKey, score]) => ({
+            member: storageKey.slice(prefix.length),
+            score,
+        }));
+        members.sort((a, b) => a.score - b.score);
+        return members;
+    }
+    async zadd(key, score, member) {
+        await this.prepareCollection(key, "zset");
+        const memberKey = this.memberKey("zset", key, member);
+        const existing = await this.storage.get(memberKey);
+        await this.storage.put(memberKey, score);
+        return existing === undefined ? 1 : 0;
+    }
+    async zrem(key, ...members) {
+        const meta = await this.readMetaOfType(key, "zset");
+        if (!meta)
+            return 0;
+        let removed = 0;
+        for (const member of members) {
+            if (await this.storage.delete(this.memberKey("zset", key, member))) {
+                removed++;
+            }
+        }
+        return removed;
+    }
+    async zscore(key, member) {
+        const meta = await this.readMetaOfType(key, "zset");
+        if (!meta)
+            return null;
+        const score = await this.storage.get(this.memberKey("zset", key, member));
+        return score ?? null;
+    }
+    async zrange(key, start, stop) {
+        const zset = await this.loadZSet(key);
+        const len = zset.length;
+        const s = start < 0 ? Math.max(len + start, 0) : start;
+        const e = stop < 0 ? len + stop : stop;
+        return zset.slice(s, e + 1).map((m) => m.member);
+    }
+    async zrangebyscore(key, min, max, options) {
+        const zset = await this.loadZSet(key);
+        const minScore = min === "-inf" ? -Infinity : min;
+        const maxScore = max === "+inf" ? Infinity : max;
+        let filtered = zset.filter((m) => m.score >= minScore && m.score <= maxScore);
+        if (options?.limit) {
+            filtered = filtered.slice(options.limit.offset, options.limit.offset + options.limit.count);
+        }
+        return filtered.map((m) => m.member);
+    }
+    async zcard(key) {
+        return (await this.loadZSet(key)).length;
+    }
+    async zincrby(key, increment, member) {
+        await this.prepareCollection(key, "zset");
+        const memberKey = this.memberKey("zset", key, member);
+        const existing = await this.storage.get(memberKey);
+        const score = (existing ?? 0) + increment;
+        await this.storage.put(memberKey, score);
+        return score;
+    }
+    async keys(pattern) {
+        const regex = globToRegex(pattern);
+        const result = [];
+        const strings = await this.storage.list({ prefix: `s${SEP}` });
+        for (const [storageKey, entry] of strings) {
+            const key = storageKey.slice(2);
+            if (entry.exp !== undefined && Date.now() > entry.exp) {
+                await this.storage.delete(storageKey);
+                continue;
+            }
+            if (regex.test(key))
+                result.push(key);
+        }
+        const metas = await this.storage.list({ prefix: `m${SEP}` });
+        for (const [storageKey, meta] of metas) {
+            const key = storageKey.slice(2);
+            if (meta.exp !== undefined && Date.now() > meta.exp) {
+                await this.deleteMembers(meta.type, key);
+                await this.storage.delete(storageKey);
+                continue;
+            }
+            if (regex.test(key))
+                result.push(key);
+        }
+        return result;
+    }
+    async scan(cursor, options) {
+        const allKeys = await this.keys(options?.match ?? "*");
+        const start = parseInt(cursor, 10) || 0;
+        const count = options?.count ?? 10;
+        const end = Math.min(start + count, allKeys.length);
+        return {
+            cursor: end >= allKeys.length ? "0" : String(end),
+            keys: allKeys.slice(start, end),
+        };
+    }
+}
+const ENGINE_OPS = new Set([
+    "get",
+    "set",
+    "del",
+    "exists",
+    "incr",
+    "incrBy",
+    "decr",
+    "expire",
+    "ttl",
+    "hget",
+    "hset",
+    "hmset",
+    "hgetall",
+    "hdel",
+    "hexists",
+    "hkeys",
+    "hlen",
+    "sadd",
+    "srem",
+    "smembers",
+    "sismember",
+    "scard",
+    "lpush",
+    "rpush",
+    "lpop",
+    "rpop",
+    "lrange",
+    "llen",
+    "ltrim",
+    "zadd",
+    "zrem",
+    "zscore",
+    "zrange",
+    "zrangebyscore",
+    "zcard",
+    "zincrby",
+    "keys",
+    "scan",
+]);
+const parseChannelList = (raw) => {
+    if (!raw)
+        return [];
+    return raw
+        .split(",")
+        .filter((part) => part.length > 0)
+        .map((part) => decodeURIComponent(part));
+};
+const readAttachmentPatterns = (socket) => {
+    try {
+        const attachment = socket.deserializeAttachment?.();
+        if (attachment &&
+            typeof attachment === "object" &&
+            Array.isArray(attachment.patterns)) {
+            return attachment.patterns;
+        }
+    }
+    catch {
+        // sockets without an attachment have no patterns
+    }
+    return [];
+};
+const createWebSocketResponse = (client) => {
+    const init = { status: 101, webSocket: client };
+    try {
+        // workerd accepts status 101 with a webSocket; Node's Response does not,
+        // so fall back to a structurally compatible object for non-CF runtimes
+        return new Response(null, init);
+    }
+    catch {
+        return { status: 101, ok: false, webSocket: client };
+    }
+};
+const jsonResponse = (body, status) => new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+});
+export class CovaraKVDurableObject {
+    constructor(state) {
+        this.state = state;
+        this.engine = new DurableKVEngine(state.storage);
+    }
+    async fetch(request) {
+        const url = new URL(request.url);
+        if (request.method === "POST" && url.pathname === "/batch") {
+            return this.handleBatch(request);
+        }
+        if (url.pathname === "/subscribe") {
+            if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") {
+                return new Response("Expected websocket upgrade", { status: 426 });
+            }
+            return this.handleSubscribe(url);
+        }
+        return new Response("Not found", { status: 404 });
+    }
+    async webSocketClose() {
+        // hibernation API shape; subscriber cleanup is handled by the runtime
+    }
+    async webSocketError() {
+        // hibernation API shape
+    }
+    async handleBatch(request) {
+        let body;
+        try {
+            body = (await request.json());
+        }
+        catch {
+            return jsonResponse({ error: "Invalid JSON body" }, 400);
+        }
+        if (!Array.isArray(body?.commands)) {
+            return jsonResponse({ error: "commands array required" }, 400);
+        }
+        const results = [];
+        for (const command of body.commands) {
+            try {
+                const value = await this.runCommand(command.op, command.args ?? []);
+                results.push({ ok: true, value: value === undefined ? null : value });
+            }
+            catch (error) {
+                results.push({
+                    ok: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                if (body.stopOnError)
+                    break;
+            }
+        }
+        return jsonResponse({ results }, 200);
+    }
+    runCommand(op, args) {
+        if (op === "publish") {
+            return this.publish(String(args[0]), String(args[1]));
+        }
+        if (!ENGINE_OPS.has(op)) {
+            throw new Error(`Unknown command: ${op}`);
+        }
+        const method = this.engine[op];
+        return method.apply(this.engine, args);
+    }
+    handleSubscribe(url) {
+        const pairConstructor = globalThis.WebSocketPair;
+        if (!pairConstructor) {
+            return new Response("WebSocketPair is not available in this runtime", {
+                status: 500,
+            });
+        }
+        const pair = new pairConstructor();
+        const client = pair["0"];
+        const server = pair["1"];
+        const channels = parseChannelList(url.searchParams.get("channels"));
+        const patterns = parseChannelList(url.searchParams.get("patterns"));
+        this.state.acceptWebSocket(server, channels);
+        server.serializeAttachment?.({ patterns });
+        return createWebSocketResponse(client);
+    }
+    publish(channel, message) {
+        const targets = new Set(this.state.getWebSockets(channel));
+        for (const socket of this.state.getWebSockets()) {
+            if (targets.has(socket))
+                continue;
+            const patterns = readAttachmentPatterns(socket);
+            if (patterns.some((pattern) => globToRegex(pattern).test(channel))) {
+                targets.add(socket);
+            }
+        }
+        const payload = JSON.stringify({ channel, message });
+        let delivered = 0;
+        for (const socket of targets) {
+            try {
+                socket.send(payload);
+                delivered++;
+            }
+            catch {
+                // skip sockets that fail to deliver
+            }
+        }
+        return delivered;
+    }
+}
+const defaultReconnectDelay = (attempt) => Math.min(250 * 2 ** attempt, 5000);
+export class DurableObjectKVStore {
+    constructor(stub, options) {
+        this.connected = false;
+        this.channelCallbacks = new Map();
+        this.patternCallbacks = new Map();
+        this.socket = null;
+        this.reconnectAttempts = 0;
+        this.reconnectTimer = null;
+        this.stub = stub;
+        this.prefix = options?.prefix ?? "";
+        this.reconnectDelay = options?.reconnectDelay ?? defaultReconnectDelay;
+    }
+    key(k) {
+        return this.prefix ? `${this.prefix}:${k}` : k;
+    }
+    stripPrefix(key) {
+        return this.prefix ? key.slice(this.prefix.length + 1) : key;
+    }
+    async execBatch(commands, stopOnError = false) {
+        const response = await this.stub.fetch("https://covara-kv/batch", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ commands, stopOnError }),
+        });
+        if (!response.ok) {
+            throw new Error(`Durable Object KV request failed with status ${response.status}`);
+        }
+        const body = (await response.json());
+        return body.results.map((result) => {
+            if (!result.ok)
+                throw new Error(result.error);
+            return result.value;
+        });
+    }
+    async call(op, ...args) {
+        while (args.length > 0 && args[args.length - 1] === undefined) {
+            args.pop();
+        }
+        const [value] = await this.execBatch([{ op, args }]);
+        return value;
+    }
+    async connect() {
+        this.connected = true;
+    }
+    async disconnect() {
+        this.connected = false;
+        this.channelCallbacks.clear();
+        this.patternCallbacks.clear();
+        this.clearReconnectTimer();
+        this.closeSocket();
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async get(key) {
+        return (await this.call("get", this.key(key)));
+    }
+    async set(key, value, options) {
+        await this.call("set", this.key(key), value, options);
+    }
+    async del(...keys) {
+        return (await this.call("del", ...keys.map((key) => this.key(key))));
+    }
+    async exists(...keys) {
+        return (await this.call("exists", ...keys.map((key) => this.key(key))));
+    }
+    async incr(key) {
+        return (await this.call("incr", this.key(key)));
+    }
+    async incrBy(key, increment) {
+        return (await this.call("incrBy", this.key(key), increment));
+    }
+    async decr(key) {
+        return (await this.call("decr", this.key(key)));
+    }
+    async expire(key, seconds) {
+        return (await this.call("expire", this.key(key), seconds));
+    }
+    async ttl(key) {
+        return (await this.call("ttl", this.key(key)));
+    }
+    async hget(key, field) {
+        return (await this.call("hget", this.key(key), field));
+    }
+    async hset(key, field, value) {
+        return (await this.call("hset", this.key(key), field, value));
+    }
+    async hmset(key, data) {
+        await this.call("hmset", this.key(key), data);
+    }
+    async hgetall(key) {
+        return (await this.call("hgetall", this.key(key)));
+    }
+    async hdel(key, ...fields) {
+        return (await this.call("hdel", this.key(key), ...fields));
+    }
+    async hexists(key, field) {
+        return (await this.call("hexists", this.key(key), field));
+    }
+    async hkeys(key) {
+        return (await this.call("hkeys", this.key(key)));
+    }
+    async hlen(key) {
+        return (await this.call("hlen", this.key(key)));
+    }
+    async sadd(key, ...members) {
+        return (await this.call("sadd", this.key(key), ...members));
+    }
+    async srem(key, ...members) {
+        return (await this.call("srem", this.key(key), ...members));
+    }
+    async smembers(key) {
+        return (await this.call("smembers", this.key(key)));
+    }
+    async sismember(key, member) {
+        return (await this.call("sismember", this.key(key), member));
+    }
+    async scard(key) {
+        return (await this.call("scard", this.key(key)));
+    }
+    async lpush(key, ...values) {
+        return (await this.call("lpush", this.key(key), ...values));
+    }
+    async rpush(key, ...values) {
+        return (await this.call("rpush", this.key(key), ...values));
+    }
+    async lpop(key) {
+        return (await this.call("lpop", this.key(key)));
+    }
+    async rpop(key) {
+        return (await this.call("rpop", this.key(key)));
+    }
+    async lrange(key, start, stop) {
+        return (await this.call("lrange", this.key(key), start, stop));
+    }
+    async llen(key) {
+        return (await this.call("llen", this.key(key)));
+    }
+    async ltrim(key, start, stop) {
+        await this.call("ltrim", this.key(key), start, stop);
+    }
+    async zadd(key, score, member) {
+        return (await this.call("zadd", this.key(key), score, member));
+    }
+    async zrem(key, ...members) {
+        return (await this.call("zrem", this.key(key), ...members));
+    }
+    async zscore(key, member) {
+        return (await this.call("zscore", this.key(key), member));
+    }
+    async zrange(key, start, stop) {
+        return (await this.call("zrange", this.key(key), start, stop));
+    }
+    async zrangebyscore(key, min, max, options) {
+        return (await this.call("zrangebyscore", this.key(key), min, max, options));
+    }
+    async zcard(key) {
+        return (await this.call("zcard", this.key(key)));
+    }
+    async zincrby(key, increment, member) {
+        return (await this.call("zincrby", this.key(key), increment, member));
+    }
+    async keys(pattern) {
+        const raw = (await this.call("keys", this.key(pattern)));
+        return raw.map((key) => this.stripPrefix(key));
+    }
+    async scan(cursor, options) {
+        const raw = (await this.call("scan", cursor, {
+            ...options,
+            match: this.key(options?.match ?? "*"),
+        }));
+        return {
+            cursor: raw.cursor,
+            keys: raw.keys.map((key) => this.stripPrefix(key)),
+        };
+    }
+    async publish(channel, message) {
+        return (await this.call("publish", channel, message));
+    }
+    async subscribe(channel, callback) {
+        const callbacks = this.channelCallbacks.get(channel);
+        if (callbacks) {
+            callbacks.add(callback);
+            return;
+        }
+        this.channelCallbacks.set(channel, new Set([callback]));
+        await this.refreshSocket();
+    }
+    async psubscribe(pattern, callback) {
+        const callbacks = this.patternCallbacks.get(pattern);
+        if (callbacks) {
+            callbacks.add(callback);
+            return;
+        }
+        this.patternCallbacks.set(pattern, new Set([callback]));
+        await this.refreshSocket();
+    }
+    async unsubscribe(channel) {
+        if (!this.channelCallbacks.delete(channel))
+            return;
+        await this.refreshSocket();
+    }
+    async punsubscribe(pattern) {
+        if (!this.patternCallbacks.delete(pattern))
+            return;
+        await this.refreshSocket();
+    }
+    multi() {
+        return new DurableObjectTransaction((commands) => this.execBatch(commands, true), (key) => this.key(key));
+    }
+    async eval(_script, _keys, _args) {
+        console.warn("Lua scripting not supported in Durable Object KV store");
+        return null;
+    }
+    async refreshSocket() {
+        this.clearReconnectTimer();
+        if (this.channelCallbacks.size === 0 && this.patternCallbacks.size === 0) {
+            this.closeSocket();
+            return;
+        }
+        const params = new URLSearchParams();
+        const channels = [...this.channelCallbacks.keys()];
+        const patterns = [...this.patternCallbacks.keys()];
+        if (channels.length > 0) {
+            params.set("channels", channels.map(encodeURIComponent).join(","));
+        }
+        if (patterns.length > 0) {
+            params.set("patterns", patterns.map(encodeURIComponent).join(","));
+        }
+        const response = await this.stub.fetch(`https://covara-kv/subscribe?${params.toString()}`, { headers: { Upgrade: "websocket" } });
+        const socket = response.webSocket;
+        if (!socket) {
+            throw new Error("Durable Object did not return a WebSocket");
+        }
+        socket.accept?.();
+        socket.addEventListener?.("message", (event) => this.dispatchMessage(event.data));
+        socket.addEventListener?.("close", () => this.handleSocketClose(socket));
+        const previous = this.socket;
+        this.socket = socket;
+        this.reconnectAttempts = 0;
+        previous?.close();
+    }
+    dispatchMessage(data) {
+        let event;
+        try {
+            event = JSON.parse(String(data));
+        }
+        catch {
+            return;
+        }
+        if (typeof event.channel !== "string" || typeof event.message !== "string") {
+            return;
+        }
+        const channel = event.channel;
+        const message = event.message;
+        const exact = this.channelCallbacks.get(channel);
+        if (exact) {
+            for (const callback of exact) {
+                callback(message, channel);
+            }
+        }
+        for (const [pattern, callbacks] of this.patternCallbacks) {
+            if (!globToRegex(pattern).test(channel))
+                continue;
+            for (const callback of callbacks) {
+                callback(message, channel);
+            }
+        }
+    }
+    handleSocketClose(socket) {
+        if (socket !== this.socket)
+            return;
+        this.socket = null;
+        if (this.channelCallbacks.size === 0 && this.patternCallbacks.size === 0) {
+            return;
+        }
+        this.scheduleReconnect();
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer)
+            return;
+        const delay = this.reconnectDelay(this.reconnectAttempts);
+        this.reconnectAttempts += 1;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            void this.refreshSocket().catch(() => this.scheduleReconnect());
+        }, delay);
+    }
+    closeSocket() {
+        const socket = this.socket;
+        this.socket = null;
+        socket?.close();
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+}
+class DurableObjectTransaction {
+    constructor(execBatch, prefixKey) {
+        this.commands = [];
+        this.execBatch = execBatch;
+        this.prefixKey = prefixKey;
+    }
+    get(key) {
+        this.commands.push({ op: "get", args: [this.prefixKey(key)] });
+        return this;
+    }
+    set(key, value, options) {
+        const args = [this.prefixKey(key), value];
+        if (options !== undefined)
+            args.push(options);
+        this.commands.push({ op: "set", args });
+        return this;
+    }
+    del(...keys) {
+        this.commands.push({ op: "del", args: keys.map((key) => this.prefixKey(key)) });
+        return this;
+    }
+    incr(key) {
+        this.commands.push({ op: "incr", args: [this.prefixKey(key)] });
+        return this;
+    }
+    hset(key, field, value) {
+        this.commands.push({ op: "hset", args: [this.prefixKey(key), field, value] });
+        return this;
+    }
+    hdel(key, ...fields) {
+        this.commands.push({ op: "hdel", args: [this.prefixKey(key), ...fields] });
+        return this;
+    }
+    sadd(key, ...members) {
+        this.commands.push({ op: "sadd", args: [this.prefixKey(key), ...members] });
+        return this;
+    }
+    srem(key, ...members) {
+        this.commands.push({ op: "srem", args: [this.prefixKey(key), ...members] });
+        return this;
+    }
+    lpush(key, ...values) {
+        this.commands.push({ op: "lpush", args: [this.prefixKey(key), ...values] });
+        return this;
+    }
+    rpush(key, ...values) {
+        this.commands.push({ op: "rpush", args: [this.prefixKey(key), ...values] });
+        return this;
+    }
+    zadd(key, score, member) {
+        this.commands.push({ op: "zadd", args: [this.prefixKey(key), score, member] });
+        return this;
+    }
+    zrem(key, ...members) {
+        this.commands.push({ op: "zrem", args: [this.prefixKey(key), ...members] });
+        return this;
+    }
+    expire(key, seconds) {
+        this.commands.push({ op: "expire", args: [this.prefixKey(key), seconds] });
+        return this;
+    }
+    async exec() {
+        const results = await this.execBatch(this.commands);
+        this.commands = [];
+        return results;
+    }
+    discard() {
+        this.commands = [];
+    }
+}
+export const createDurableObjectKV = (namespace, options) => {
+    const stub = namespace.get(namespace.idFromName(options?.name ?? "covara-kv"));
+    return new DurableObjectKVStore(stub, {
+        prefix: options?.prefix,
+        reconnectDelay: options?.reconnectDelay,
+    });
+};
+//# sourceMappingURL=durable-object.js.map