@interncom/diplomatic 0.0.15 → 0.0.17

package/dist/client.d.ts

@@ -18,6 +18,7 @@ export default class DiplomaticClient {
     hostKeyPair?: KeyPair;
     lastFetchedAt?: string;
     constructor(params: IDiplomaticClientParams);
+    wipe(): Promise<void>;
     websocket?: WebSocket;
     connect: (hostURL: URL) => Promise<void>;
     init(params: IDiplomaticClientParams): Promise<void>;

package/dist/index.mjs

@@ -16,12 +16,17 @@ function useClientState(client) {
   const [state, setState] = useState();
   useEffect(() => {
     async function updateState() {
+      console.log("updating");
       const state2 = await client.getState();
+      console.log("updated", state2);
       setState(state2);
+      console.log("updated and set state");
     }
+    console.log("hooking");
     client.listener = updateState;
     updateState();
     return () => {
+      console.log("unhooking");
       client.listener = void 0;
     };
   }, [client]);
@@ -316,27 +321,16 @@ function openDB(name, version, { blocked, upgrade, blocking, terminated } = {})
       event
     ));
   }
-  openPromise.then((db) => {
+  openPromise.then((db2) => {
     if (terminated)
-      db.addEventListener("close", () => terminated());
+      db2.addEventListener("close", () => terminated());
     if (blocking) {
-      db.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
+      db2.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
     }
   }).catch(() => {
   });
   return openPromise;
 }
-function deleteDB(name, { blocked } = {}) {
-  const request = indexedDB.deleteDatabase(name);
-  if (blocked) {
-    request.addEventListener("blocked", (event) => blocked(
-      // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
-      event.oldVersion,
-      event
-    ));
-  }
-  return wrap(request).then(() => void 0);
-}
 var readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
 var writeMethods = ["put", "add", "delete", "clear"];
 var cachedMethods = /* @__PURE__ */ new Map();
@@ -423,13 +417,13 @@ replaceTraps((oldTraps) => ({
 }));
 
 // src/idbStore.ts
-var dbPromise = openDB("client-store-db", 1, {
-  upgrade(db) {
-    db.createObjectStore("metaKV");
-    db.createObjectStore("uploadQueue", {
+var db = await openDB("client-store-db", 2, {
+  upgrade(db2) {
+    db2.createObjectStore("metaKV");
+    db2.createObjectStore("uploadQueue", {
       keyPath: "sha256"
     });
-    db.createObjectStore("downloadQueue", {
+    db2.createObjectStore("downloadQueue", {
       keyPath: "path"
     });
   }
@@ -439,10 +433,11 @@ var IDBStore = class {
   hostURL;
   hostID;
   async wipe() {
-    await deleteDB("client-store-db");
+    await db.clear("metaKV");
+    await db.clear("uploadQueue");
+    await db.clear("downloadQueue");
   }
   async getSeed() {
-    const db = await dbPromise;
     const hex = await db.get("metaKV", "seed");
     if (!hex) {
       return;
@@ -452,68 +447,56 @@ var IDBStore = class {
   }
   async setSeed(seed) {
     const hex = btoh(seed);
-    const db = await dbPromise;
     await db.put("metaKV", hex, "seed");
     this.seed = seed;
   }
   async getHostURL() {
-    const db = await dbPromise;
     const url = await db.get("metaKV", "hostURL");
     return url;
   }
   async setHostURL(url) {
-    const db = await dbPromise;
     db.put("metaKV", url, "hostURL");
   }
   async getHostID() {
-    const db = await dbPromise;
     const id = await db.get("metaKV", "hostID");
     return id;
   }
   async setHostID(id) {
-    const db = await dbPromise;
     await db.put("metaKV", id, "hostID");
   }
   uploadQueue = /* @__PURE__ */ new Map();
   enqueueUpload = async (sha256, cipherOp) => {
-    const db = await dbPromise;
     await db.put("uploadQueue", { sha256, cipherOp });
   };
   dequeueUpload = async (sha256) => {
-    const db = await dbPromise;
     await db.delete("uploadQueue", sha256);
   };
   peekUpload = async (sha256) => {
-    const db = await dbPromise;
     const row = await db.get("uploadQueue", sha256);
     return row?.cipherOp;
   };
   listUploads = async () => {
-    const db = await dbPromise;
     const sha256s = await db.getAllKeys("uploadQueue");
     return sha256s;
   };
   numUploads = async () => {
-    const db = await dbPromise;
-    return db.count("uploadQueue");
+    const num = await db.count("uploadQueue");
+    return num;
   };
   downloadQueue = /* @__PURE__ */ new Set();
   enqueueDownload = async (path) => {
-    const db = await dbPromise;
     await db.put("downloadQueue", { path });
   };
   dequeueDownload = async (path) => {
-    const db = await dbPromise;
     await db.delete("downloadQueue", path);
   };
   listDownloads = async () => {
-    const db = await dbPromise;
     const paths = await db.getAllKeys("downloadQueue");
     return paths;
   };
   numDownloads = async () => {
-    const db = await dbPromise;
-    return db.count("downloadQueue");
+    const num = await db.count("downloadQueue");
+    return num;
   };
 };
 var idbStore = new IDBStore();
@@ -8810,6 +8793,17 @@ var DiplomaticClient = class {
     this.applier = params.stateManager.apply;
     this.init(params);
   }
+  async wipe() {
+    this.seed = void 0;
+    this.encKey = void 0;
+    this.hostURL = void 0;
+    this.hostKeyPair = void 0;
+    this.lastFetchedAt = void 0;
+    this.websocket?.close();
+    this.websocket = void 0;
+    await this.store.wipe();
+    this.emitUpdate();
+  }
   websocket;
   connect = async (hostURL) => {
     if (!this.hostKeyPair) {
@@ -8842,6 +8836,7 @@ var DiplomaticClient = class {
     };
   };
   async init(params) {
+    await this.store.init?.();
     if (params.seed) {
       const bytes = typeof params.seed === "string" ? htob(params.seed) : params.seed;
       await this.store.setSeed(bytes);
@@ -8904,13 +8899,12 @@ var DiplomaticClient = class {
     this.listener?.(state);
   }
   async getState() {
-    return {
-      hasSeed: this.seed !== void 0 && this.encKey !== void 0,
-      hasHost: this.hostURL !== void 0 && this.hostKeyPair !== void 0,
-      connected: this.websocket?.readyState === WebSocket.OPEN,
-      numUploads: await this.store.numUploads(),
-      numDownloads: await this.store.numDownloads()
-    };
+    const hasSeed = this.seed !== void 0 && this.encKey !== void 0;
+    const hasHost = this.hostURL !== void 0 && this.hostKeyPair !== void 0;
+    const connected = this.websocket === void 0 ? false : this.websocket.readyState === this.websocket.OPEN;
+    const numUploads = await this.store.numUploads();
+    const numDownloads = await this.store.numDownloads();
+    return { hasSeed, hasHost, connected, numDownloads, numUploads };
   }
   async processOps() {
     await this.pullOpPaths();

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 import type { IOp } from "./shared/types";
 export interface IClientStateStore {
+    init?: () => Promise<void>;
     getSeed: () => Promise<Uint8Array | undefined>;
     setSeed: (seed: Uint8Array) => Promise<void>;
     getHostURL: () => Promise<string | undefined>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interncom/diplomatic",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "type": "module",
   "description": "Secure sync layer",
   "main": "dist/index.mjs",