@interncom/diplomatic 0.0.10 → 0.0.12

package/dist/idbStore.d.ts

@@ -0,0 +1,23 @@
+import type { IClientStateStore } from "./types";
+declare class IDBStore implements IClientStateStore {
+    seed?: Uint8Array;
+    hostURL?: string;
+    hostID?: string;
+    getSeed(): Promise<Uint8Array | undefined>;
+    setSeed(seed: Uint8Array): Promise<void>;
+    getHostURL(): Promise<string | undefined>;
+    setHostURL(url: string): Promise<void>;
+    getHostID(): Promise<string | undefined>;
+    setHostID(id: string): Promise<void>;
+    uploadQueue: Map<string, Uint8Array>;
+    enqueueUpload: (sha256: string, cipherOp: Uint8Array) => Promise<void>;
+    dequeueUpload: (sha256: string) => Promise<void>;
+    peekUpload: (sha256: string) => Promise<Uint8Array | undefined>;
+    listUploads: () => Promise<string[]>;
+    downloadQueue: Set<string>;
+    enqueueDownload: (path: string) => Promise<void>;
+    dequeueDownload: (path: string) => Promise<void>;
+    listDownloads: () => Promise<string[]>;
+}
+export declare const idbStore: IDBStore;
+export {};

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import { useClientState } from "./useClient";
 import { StateManager, useStateWatcher } from './state';
 import { localStorageStore } from "./localStorageStore";
+import { idbStore } from "./idbStore";
 import DiplomaticClient from "./client";
 import libsodiumCrypto from "./crypto";
 import { btoh, htob } from "./shared/lib";
 import { type IOp, Verb } from "./shared/types";
-export { useClientState, StateManager, useStateWatcher, localStorageStore, DiplomaticClient, libsodiumCrypto, btoh, htob, Verb, };
+export { useClientState, StateManager, useStateWatcher, localStorageStore, idbStore, DiplomaticClient, libsodiumCrypto, btoh, htob, Verb, };
 export type { IOp, };

package/dist/index.mjs

@@ -80,31 +80,6 @@ function useStateWatcher(mgr, opType, callback) {
   return val;
 }
 
-// src/queue.ts
-var Queue = class {
-  map;
-  constructor() {
-    this.map = /* @__PURE__ */ new Map();
-  }
-  async enqueue(key, value) {
-    this.map.set(key, value);
-  }
-  async peek(key) {
-    return this.map.get(key);
-  }
-  async entries() {
-    return this.map.entries();
-  }
-  async dequeue(key) {
-    const value = this.map.get(key);
-    this.map.delete(key);
-    return value;
-  }
-  async size() {
-    return this.map.size;
-  }
-};
-
 // ../shared/lib.ts
 function btoh(bytes) {
   const hex = Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
@@ -149,11 +124,330 @@ var LocalStorageStore = class {
   async setHostID(id) {
     return localStorage.setItem(hostIDKey, id);
   }
-  pushQueue = new Queue();
-  pullQueue = new Queue();
+  uploadQueue = /* @__PURE__ */ new Map();
+  enqueueUpload = async (sha256, cipherOp) => {
+    this.uploadQueue.set(sha256, cipherOp);
+  };
+  dequeueUpload = async (sha256) => {
+    this.uploadQueue.delete(sha256);
+  };
+  peekUpload = async (sha256) => {
+    return this.uploadQueue.get(sha256);
+  };
+  listUploads = async () => {
+    return Array.from(this.uploadQueue.keys());
+  };
+  downloadQueue = /* @__PURE__ */ new Set();
+  enqueueDownload = async (path) => {
+    this.downloadQueue.add(path);
+  };
+  dequeueDownload = async (path) => {
+    this.downloadQueue.delete(path);
+  };
+  listDownloads = async () => {
+    return Array.from(this.downloadQueue.keys());
+  };
 };
 var localStorageStore = new LocalStorageStore();
 
+// node_modules/idb/build/index.js
+var instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+var idbProxyableTypes;
+var cursorAdvanceMethods;
+function getIdbProxyableTypes() {
+  return idbProxyableTypes || (idbProxyableTypes = [
+    IDBDatabase,
+    IDBObjectStore,
+    IDBIndex,
+    IDBCursor,
+    IDBTransaction
+  ]);
+}
+function getCursorAdvanceMethods() {
+  return cursorAdvanceMethods || (cursorAdvanceMethods = [
+    IDBCursor.prototype.advance,
+    IDBCursor.prototype.continue,
+    IDBCursor.prototype.continuePrimaryKey
+  ]);
+}
+var transactionDoneMap = /* @__PURE__ */ new WeakMap();
+var transformCache = /* @__PURE__ */ new WeakMap();
+var reverseTransformCache = /* @__PURE__ */ new WeakMap();
+function promisifyRequest(request) {
+  const promise = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      request.removeEventListener("success", success);
+      request.removeEventListener("error", error);
+    };
+    const success = () => {
+      resolve(wrap(request.result));
+      unlisten();
+    };
+    const error = () => {
+      reject(request.error);
+      unlisten();
+    };
+    request.addEventListener("success", success);
+    request.addEventListener("error", error);
+  });
+  reverseTransformCache.set(promise, request);
+  return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+  if (transactionDoneMap.has(tx))
+    return;
+  const done = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      tx.removeEventListener("complete", complete);
+      tx.removeEventListener("error", error);
+      tx.removeEventListener("abort", error);
+    };
+    const complete = () => {
+      resolve();
+      unlisten();
+    };
+    const error = () => {
+      reject(tx.error || new DOMException("AbortError", "AbortError"));
+      unlisten();
+    };
+    tx.addEventListener("complete", complete);
+    tx.addEventListener("error", error);
+    tx.addEventListener("abort", error);
+  });
+  transactionDoneMap.set(tx, done);
+}
+var idbProxyTraps = {
+  get(target, prop, receiver) {
+    if (target instanceof IDBTransaction) {
+      if (prop === "done")
+        return transactionDoneMap.get(target);
+      if (prop === "store") {
+        return receiver.objectStoreNames[1] ? void 0 : receiver.objectStore(receiver.objectStoreNames[0]);
+      }
+    }
+    return wrap(target[prop]);
+  },
+  set(target, prop, value) {
+    target[prop] = value;
+    return true;
+  },
+  has(target, prop) {
+    if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) {
+      return true;
+    }
+    return prop in target;
+  }
+};
+function replaceTraps(callback) {
+  idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+  if (getCursorAdvanceMethods().includes(func)) {
+    return function(...args) {
+      func.apply(unwrap(this), args);
+      return wrap(this.request);
+    };
+  }
+  return function(...args) {
+    return wrap(func.apply(unwrap(this), args));
+  };
+}
+function transformCachableValue(value) {
+  if (typeof value === "function")
+    return wrapFunction(value);
+  if (value instanceof IDBTransaction)
+    cacheDonePromiseForTransaction(value);
+  if (instanceOfAny(value, getIdbProxyableTypes()))
+    return new Proxy(value, idbProxyTraps);
+  return value;
+}
+function wrap(value) {
+  if (value instanceof IDBRequest)
+    return promisifyRequest(value);
+  if (transformCache.has(value))
+    return transformCache.get(value);
+  const newValue = transformCachableValue(value);
+  if (newValue !== value) {
+    transformCache.set(value, newValue);
+    reverseTransformCache.set(newValue, value);
+  }
+  return newValue;
+}
+var unwrap = (value) => reverseTransformCache.get(value);
+function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
+  const request = indexedDB.open(name, version);
+  const openPromise = wrap(request);
+  if (upgrade) {
+    request.addEventListener("upgradeneeded", (event) => {
+      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+    });
+  }
+  if (blocked) {
+    request.addEventListener("blocked", (event) => blocked(
+      // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+      event.oldVersion,
+      event.newVersion,
+      event
+    ));
+  }
+  openPromise.then((db) => {
+    if (terminated)
+      db.addEventListener("close", () => terminated());
+    if (blocking) {
+      db.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
+    }
+  }).catch(() => {
+  });
+  return openPromise;
+}
+var readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
+var writeMethods = ["put", "add", "delete", "clear"];
+var cachedMethods = /* @__PURE__ */ new Map();
+function getMethod(target, prop) {
+  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) {
+    return;
+  }
+  if (cachedMethods.get(prop))
+    return cachedMethods.get(prop);
+  const targetFuncName = prop.replace(/FromIndex$/, "");
+  const useIndex = prop !== targetFuncName;
+  const isWrite = writeMethods.includes(targetFuncName);
+  if (
+    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))
+  ) {
+    return;
+  }
+  const method = async function(storeName, ...args) {
+    const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
+    let target2 = tx.store;
+    if (useIndex)
+      target2 = target2.index(args.shift());
+    return (await Promise.all([
+      target2[targetFuncName](...args),
+      isWrite && tx.done
+    ]))[0];
+  };
+  cachedMethods.set(prop, method);
+  return method;
+}
+replaceTraps((oldTraps) => ({
+  ...oldTraps,
+  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+}));
+var advanceMethodProps = ["continue", "continuePrimaryKey", "advance"];
+var methodMap = {};
+var advanceResults = /* @__PURE__ */ new WeakMap();
+var ittrProxiedCursorToOriginalProxy = /* @__PURE__ */ new WeakMap();
+var cursorIteratorTraps = {
+  get(target, prop) {
+    if (!advanceMethodProps.includes(prop))
+      return target[prop];
+    let cachedFunc = methodMap[prop];
+    if (!cachedFunc) {
+      cachedFunc = methodMap[prop] = function(...args) {
+        advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+      };
+    }
+    return cachedFunc;
+  }
+};
+async function* iterate(...args) {
+  let cursor = this;
+  if (!(cursor instanceof IDBCursor)) {
+    cursor = await cursor.openCursor(...args);
+  }
+  if (!cursor)
+    return;
+  cursor = cursor;
+  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+  while (cursor) {
+    yield proxiedCursor;
+    cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
+    advanceResults.delete(proxiedCursor);
+  }
+}
+function isIteratorProp(target, prop) {
+  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === "iterate" && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
+}
+replaceTraps((oldTraps) => ({
+  ...oldTraps,
+  get(target, prop, receiver) {
+    if (isIteratorProp(target, prop))
+      return iterate;
+    return oldTraps.get(target, prop, receiver);
+  },
+  has(target, prop) {
+    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+  }
+}));
+
+// src/idbStore.ts
+var dbPromise = openDB("client-store-db", 1, {
+  upgrade(db) {
+    db.createObjectStore("metaKV");
+  }
+});
+var IDBStore = class {
+  seed;
+  hostURL;
+  hostID;
+  async getSeed() {
+    const hex = await (await dbPromise).get("metaKV", "seed");
+    if (!hex) {
+      return;
+    }
+    const bytes = htob(hex);
+    return bytes;
+  }
+  async setSeed(seed) {
+    const hex = btoh(seed);
+    (await dbPromise).put("metaKV", hex, "seed");
+    this.seed = seed;
+  }
+  async getHostURL() {
+    const url = await (await dbPromise).get("metaKV", "hostURL");
+    return url;
+  }
+  async setHostURL(url) {
+    (await dbPromise).put("metaKV", url, "hostURL");
+  }
+  async getHostID() {
+    const id = await (await dbPromise).get("metaKV", "hostID");
+    return id;
+  }
+  async setHostID(id) {
+    (await dbPromise).put("metaKV", id, "hostID");
+  }
+  uploadQueue = /* @__PURE__ */ new Map();
+  enqueueUpload = async (sha256, cipherOp) => {
+    this.uploadQueue.set(sha256, cipherOp);
+  };
+  dequeueUpload = async (sha256) => {
+    this.uploadQueue.delete(sha256);
+  };
+  peekUpload = async (sha256) => {
+    return this.uploadQueue.get(sha256);
+  };
+  listUploads = async () => {
+    return Array.from(this.uploadQueue.keys());
+  };
+  downloadQueue = /* @__PURE__ */ new Set();
+  enqueueDownload = async (path) => {
+    this.downloadQueue.add(path);
+  };
+  dequeueDownload = async (path) => {
+    this.downloadQueue.delete(path);
+  };
+  listDownloads = async () => {
+    return Array.from(this.downloadQueue.keys());
+  };
+};
+var idbStore = new IDBStore();
+
 // node_modules/@msgpack/msgpack/dist.es5+esm/utils/utf8.mjs
 function utf8Count(str) {
   var strLength = str.length;
@@ -8556,7 +8850,7 @@ var DiplomaticClient = class {
     const pathResp = await api_default.getDeltaPaths(hostURL, begin, hostKeyPair);
     const paths = pathResp.paths;
     for (const path of paths) {
-      await this.store.pullQueue.enqueue(path, null);
+      await this.store.enqueueDownload(path);
     }
     this.lastFetchedAt = pathResp.fetchedAt;
   }
@@ -8565,17 +8859,19 @@ var DiplomaticClient = class {
       return [];
     }
     const { hostURL, hostKeyPair, encKey } = this;
-    for (const [path] of await this.store.pullQueue.entries()) {
-      const cipher = await api_default.getDelta(this.hostURL, path, hostKeyPair);
+    const paths = await this.store.listDownloads();
+    paths.sort((p1, p2) => p2.localeCompare(p1));
+    for (const path of paths) {
+      const cipher = await api_default.getDelta(hostURL, path, hostKeyPair);
       const packed = await crypto_default.decryptXSalsa20Poly1305Combined(cipher, encKey);
       const op = decode(packed);
       try {
         await this.applier(op);
-        this.store.pullQueue.dequeue(path);
+        await this.store.dequeueDownload(path);
       } catch {
         const transient = true;
         if (!transient) {
-          this.store.pullQueue.dequeue(path);
+          await this.store.dequeueDownload(path);
         }
       }
     }
@@ -8584,14 +8880,14 @@ var DiplomaticClient = class {
     if (!this.hostURL || !this.hostKeyPair) {
       return;
     }
-    const cipherOp = await this.store.pushQueue.peek(sha256);
+    const cipherOp = await this.store.peekUpload(sha256);
     if (cipherOp) {
       await api_default.putDelta(this.hostURL, cipherOp, this.hostKeyPair);
     }
-    await this.store.pushQueue.dequeue(sha256);
+    await this.store.dequeueUpload(sha256);
   }
   async pushQueuedOps() {
-    for (const [sha256] of await this.store.pushQueue.entries()) {
+    for (const sha256 of await this.store.listUploads()) {
       await this.pushQueuedOp(sha256);
     }
   }
@@ -8607,11 +8903,11 @@ var DiplomaticClient = class {
     const cipherOp = await crypto_default.encryptXSalsa20Poly1305Combined(packed, this.encKey);
     const sha256 = await crypto_default.sha256Hash(cipherOp);
     const shaHex = btoh(sha256);
-    await this.store.pushQueue.enqueue(shaHex, cipherOp);
+    await this.store.enqueueUpload(shaHex, cipherOp);
     try {
       await this.applier(op);
     } catch {
-      await this.store.pushQueue.dequeue(shaHex);
+      await this.store.dequeueUpload(shaHex);
     }
     await this.pushQueuedOp(shaHex);
   }
@@ -8626,6 +8922,7 @@ export {
   Verb,
   btoh,
   htob,
+  idbStore,
   crypto_default as libsodiumCrypto,
   localStorageStore,
   useClientState,

package/dist/localStorageStore.d.ts

@@ -1,4 +1,3 @@
-import { Queue } from "./queue";
 import type { IClientStateStore } from "./types";
 declare class LocalStorageStore implements IClientStateStore {
     getSeed(): Promise<Uint8Array | undefined>;
@@ -7,8 +6,15 @@ declare class LocalStorageStore implements IClientStateStore {
     setHostURL(url: string): Promise<void>;
     getHostID(): Promise<string | undefined>;
     setHostID(id: string): Promise<void>;
-    pushQueue: Queue<string, Uint8Array>;
-    pullQueue: Queue<string, null>;
+    uploadQueue: Map<string, Uint8Array>;
+    enqueueUpload: (sha256: string, cipherOp: Uint8Array) => Promise<void>;
+    dequeueUpload: (sha256: string) => Promise<void>;
+    peekUpload: (sha256: string) => Promise<Uint8Array | undefined>;
+    listUploads: () => Promise<string[]>;
+    downloadQueue: Set<string>;
+    enqueueDownload: (path: string) => Promise<void>;
+    dequeueDownload: (path: string) => Promise<void>;
+    listDownloads: () => Promise<string[]>;
 }
 export declare const localStorageStore: LocalStorageStore;
 export {};

package/dist/memoryStore.d.ts

@@ -0,0 +1,23 @@
+import type { IClientStateStore } from "./types";
+declare class MemoryStore implements IClientStateStore {
+    seed?: Uint8Array;
+    hostURL?: string;
+    hostID?: string;
+    getSeed(): Promise<Uint8Array | undefined>;
+    setSeed(seed: Uint8Array): Promise<void>;
+    getHostURL(): Promise<string | undefined>;
+    setHostURL(url: string): Promise<void>;
+    getHostID(): Promise<string | undefined>;
+    setHostID(id: string): Promise<void>;
+    uploadQueue: Map<string, Uint8Array>;
+    enqueueUpload: (sha256: string, cipherOp: Uint8Array) => Promise<void>;
+    dequeueUpload: (sha256: string) => Promise<void>;
+    peekUpload: (sha256: string) => Promise<Uint8Array | undefined>;
+    listUploads: () => Promise<string[]>;
+    downloadQueue: Set<string>;
+    enqueueDownload: (path: string) => Promise<void>;
+    dequeueDownload: (path: string) => Promise<void>;
+    listDownloads: () => Promise<string[]>;
+}
+export declare const memoryStore: MemoryStore;
+export {};

package/dist/queue.d.ts

@@ -4,7 +4,7 @@ export declare class Queue<K, V> implements IQueue<K, V> {
     constructor();
     enqueue(key: K, value: V): Promise<void>;
     peek(key: K): Promise<V | undefined>;
-    entries(): Promise<Iterable<[K, V]>>;
+    entries(): Promise<Array<[K, V]>>;
     dequeue(key: K): Promise<V | undefined>;
     size(): Promise<number>;
 }

package/dist/types.d.ts

@@ -1,34 +1,4 @@
 import type { IOp } from "./shared/types";
-export interface IQueue<K, V> {
-    /**
-     * Adds an entry to the queue.
-     * @param key - The key of the entry.
-     * @param value - The value of the entry.
-     */
-    enqueue(key: K, value: V): Promise<void>;
-    /**
-     * Returns the value of the entry with the specified key without removing it.
-     * @param key - The key of the entry.
-     * @returns The value of the entry if found, or undefined if the key does not exist.
-     */
-    peek(key: K): Promise<V | undefined>;
-    /**
-     * Returns an iterator for the queue, allowing iteration over all entries.
-     * @returns An iterator of entries in the queue.
-     */
-    entries(): Promise<Iterable<[K, V]>>;
-    /**
-     * Removes the entry with the specified key from the queue.
-     * @param key - The key of the entry.
-     * @returns The value of the removed entry if found, or undefined if the key does not exist.
-     */
-    dequeue(key: K): Promise<V | undefined>;
-    /**
-     * Returns the number of entries in the queue.
-     * @returns The size of the queue.
-     */
-    size(): Promise<number>;
-}
 export interface IClientStateStore {
     init?: () => Promise<void>;
     getSeed: () => Promise<Uint8Array | undefined>;
@@ -37,8 +7,13 @@ export interface IClientStateStore {
     setHostURL: (url: string) => Promise<void>;
     getHostID: () => Promise<string | undefined>;
     setHostID: (id: string) => Promise<void>;
-    pushQueue: IQueue<string, Uint8Array>;
-    pullQueue: IQueue<string, null>;
+    enqueueUpload: (sha256: string, cipherOp: Uint8Array) => Promise<void>;
+    dequeueUpload: (sha256: string) => Promise<void>;
+    peekUpload: (sha256: string) => Promise<Uint8Array | undefined>;
+    listUploads: () => Promise<string[]>;
+    enqueueDownload: (path: string) => Promise<void>;
+    dequeueDownload: (path: string) => Promise<void>;
+    listDownloads: () => Promise<string[]>;
 }
 export type DiplomaticClientState = "loading" | "seedless" | "hostless" | "ready";
 export type Applier = (op: IOp) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interncom/diplomatic",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "type": "module",
   "description": "Secure sync layer",
   "main": "dist/index.mjs",
@@ -10,7 +10,8 @@
   ],
   "scripts": {
     "tsc": "tsc",
-    "build": "node esbuild.mjs"
+    "build": "node esbuild.mjs",
+    "test": "vitest"
   },
   "author": "The Internet Committee",
   "license": "ISC",
@@ -19,14 +20,16 @@
   },
   "devDependencies": {
     "@types/react": "^18.3.3",
-    "react": "^18.3.1",
     "esbuild": "0.21.5",
-    "typescript": "^5.5.2"
+    "react": "^18.3.1",
+    "typescript": "^5.5.2",
+    "vitest": "^1.6.0"
   },
   "peerDependencies": {
     "react": "^18.3.1"
   },
   "dependencies": {
-    "@msgpack/msgpack": "^3.0.0-beta2"
+    "@msgpack/msgpack": "^3.0.0-beta2",
+    "idb": "^8.0.0"
   }
 }